In calls to the emem_tree routines, forcibly align items not known to be

aligned on 32-bit boundaries.

git-svn-id: http://anonsvn.wireshark.org/wireshark/trunk@21611 f5534014-38df-0310-8fa8-9805f1628bb7

diff --git a/epan/dissectors/packet-nfs.c b/epan/dissectors/packet-nfs.c
index c942ccb4fc8d1812863fe36bafe353d7f85cc0c1..1adfe13a76bc9b19f02dc958b9edac99ccd9cd53 100644 (file)
--- a/epan/dissectors/packet-nfs.c
+++ b/epan/dissectors/packet-nfs.c
@@ -549,18 +549,23 @@ static nfs_fhandle_data_t *
 store_nfs_file_handle(nfs_fhandle_data_t *nfs_fh)
 {
        guint32 fhlen;
+       guint32 *fhdata;
        emem_tree_key_t fhkey[3];
        nfs_fhandle_data_t *new_nfs_fh;
 
        fhlen=nfs_fh->len/4;
+       /* align the file handle data */
+       fhdata=g_malloc(fhlen*4);
+       memcpy(fhdata, nfs_fh->fh, fhlen*4);
        fhkey[0].length=1;
        fhkey[0].key=&fhlen;
        fhkey[1].length=fhlen;
-       fhkey[1].key=(guint32 *)nfs_fh->fh;
+       fhkey[1].key=fhdata;
        fhkey[2].length=0;
 
        new_nfs_fh=se_tree_lookup32_array(nfs_file_handles, &fhkey[0]);
        if(new_nfs_fh){
+               g_free(fhdata);
                return new_nfs_fh;
        }
 
@@ -573,10 +578,11 @@ store_nfs_file_handle(nfs_fhandle_data_t *nfs_fh)
        fhkey[0].length=1;
        fhkey[0].key=&fhlen;
        fhkey[1].length=fhlen;
-       fhkey[1].key=(guint32 *)nfs_fh->fh;
+       fhkey[1].key=fhdata;
        fhkey[2].length=0;
        se_tree_insert32_array(nfs_file_handles, &fhkey[0], new_nfs_fh);
 
+       g_free(fhdata);
        return new_nfs_fh;
 }
 
@@ -829,15 +835,20 @@ nfs_name_snoop_fh(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int fh_of
                nns=g_hash_table_lookup(nfs_name_snoop_matched, &key);
                if(nns){
                        guint32 fhlen;
+                       guint32 *fhdata;
                        emem_tree_key_t fhkey[3];
 
                        fhlen=nns->fh_length;
+                       /* align it */
+                       fhdata=g_malloc(fhlen);
+                       memcpy(fhdata, nns->fh, fhlen);
                        fhkey[0].length=1;
                        fhkey[0].key=&fhlen;
                        fhkey[1].length=fhlen/4;
-                       fhkey[1].key=(guint32 *)nns->fh;
+                       fhkey[1].key=fhdata;
                        fhkey[2].length=0;
                        se_tree_insert32_array(nfs_name_snoop_known, &fhkey[0], nns);
+                       g_free(fhdata);
 
                        if(nfs_file_name_full_snooping){
                                unsigned char *name=NULL, *pos=NULL;
@@ -855,16 +866,20 @@ nfs_name_snoop_fh(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int fh_of
        /* see if we know this mapping */
        if(!nns){
                guint32 fhlen;
+               guint32 *fhdata;
                emem_tree_key_t fhkey[3];
 
                fhlen=fh_length;
+               /* align it */
+               fhdata=tvb_memdup(tvb, fh_offset, fh_length);
                fhkey[0].length=1;
                fhkey[0].key=&fhlen;
                fhkey[1].length=fhlen/4;
-               fhkey[1].key=(guint32 *)tvb_get_ptr(tvb, fh_offset, fh_length);
+               fhkey[1].key=fhdata;
                fhkey[2].length=0;
 
                nns=se_tree_lookup32_array(nfs_name_snoop_known, &fhkey[0]);
+               g_free(fhdata);
        }
 
        /* if we know the mapping, print the filename */

diff --git a/epan/emem.c b/epan/emem.c
index 5b66e90c3815cf6572ffb9cab4b366126f09c454..bae87b0cfd2c7fb72fdbefc65c0a10ded736e787 100644 (file)
--- a/epan/emem.c
+++ b/epan/emem.c
@@ -1431,24 +1431,29 @@ void
 emem_tree_insert_string(emem_tree_t* se_tree, const gchar* k, void* v) {
        guint32 len = strlen(k);
        guint32 div = (len-1)/4;
+       guint32 *aligned;
        guint32 residual = 0;
-       emem_tree_key_t key[] = {
-               {1,NULL},
-               {0,NULL},
-               {1,NULL},
-               {0,NULL}
-       };
+       emem_tree_key_t key[4];
 
-       key[0].key = &len;
-       key[1].length = div;
-       key[1].key = (guint32*)(&k[0]);
-       key[2].key = &residual;
+       aligned = malloc(div * sizeof (guint32));
+       if (aligned == NULL)
+               return; /* XXX - fail somehow? */
+       memcpy(aligned, k, div * sizeof (guint32));
 
+       key[0].length = 1;
+       key[0].key = &len;
        if (! div) {
-               key[1].length = key[2].length;
-               key[1].key = key[2].key;
+               key[1].length = 1;
+               key[1].key = &residual;
                key[2].length = 0;
                key[2].key = NULL;
+       } else {
+               key[1].length = div;
+               key[1].key = aligned;
+               key[2].length = 1;
+               key[2].key = &residual;
+               key[3].length = 0;
+               key[3].key = NULL;
        }
 
        div *= 4;
@@ -1466,30 +1471,37 @@ emem_tree_insert_string(emem_tree_t* se_tree, const gchar* k, void* v) {
        }
 
        emem_tree_insert32_array(se_tree,key,v);
+       free(aligned);
 }
 
 void *
 emem_tree_lookup_string(emem_tree_t* se_tree, const gchar* k) {
        guint32 len = strlen(k);
        guint32 div = (len-1)/4;
+       guint32 *aligned;
        guint32 residual = 0;
-       emem_tree_key_t key[] = {
-               {1,NULL},
-               {0,NULL},
-               {1,NULL},
-               {0,NULL}
-       };
+       emem_tree_key_t key[4];
+       void *ret;
 
-       key[0].key = &len;
-       key[1].length = div;
-       key[1].key = (guint32*)(&k[0]);
-       key[2].key = &residual;
+       aligned = malloc(div * sizeof (guint32));
+       if (aligned == NULL)
+               return; /* XXX - fail somehow? */
+       memcpy(aligned, k, div * sizeof (guint32));
 
+       key[0].length = 1;
+       key[0].key = &len;
        if (! div) {
-               key[1].length = key[2].length;
-               key[1].key = key[2].key;
+               key[1].length = 1;
+               key[1].key = &residual;
                key[2].length = 0;
                key[2].key = NULL;
+       } else {
+               key[1].length = div;
+               key[1].key = aligned;
+               key[2].length = 1;
+               key[2].key = &residual;
+               key[3].length = 0;
+               key[3].key = NULL;
        }
 
        div *= 4;
@@ -1506,7 +1518,9 @@ emem_tree_lookup_string(emem_tree_t* se_tree, const gchar* k) {
                        break;
        }
 
-       return emem_tree_lookup32_array(se_tree, key);
+       ret = emem_tree_lookup32_array(se_tree, key);
+       free(aligned);
+       return ret;
 }
 
 

diff --git a/epan/emem.h b/epan/emem.h
index e834caa6c9835f7802ebc613b2197c46cc9a95f7..a440b9f61f17740f9183add66047eb7d0ee7134a 100644 (file)
--- a/epan/emem.h
+++ b/epan/emem.h
@@ -309,6 +309,10 @@ typedef struct _emem_tree_key_t {
  * The data pointer should be allocated by SE allocators so that the
  * data will be released at the same time as the tree itself is destroyed.
  *
+ * Note: all the "key" members of the "key" argument MUST be aligned on
+ * 32-bit boundaries; otherwise, this code will crash on platforms such
+ * as SPARC that require aligned pointers.
+ *
  * If you use ...32_array() calls you MUST make sure that every single node
  * you add to a specific tree always has a key of exactly the same number of 
  * keylen words or things will most likely crash. Or at least that every single