Upgrade from trousers 0.3.3 to 0.3.6 and from testsuite 0.2 to 0.3.

src/tcs/ps/ps_utils.c

-
 /*
  * Licensed Materials - Property of IBM
  *
  * trousers - An open source TCG Software Stack
  *
  * (C) Copyright International Business Machines Corp. 2004
  *
  */
 
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#if defined(HAVE_BYTEORDER_H)
+#include <sys/byteorder.h>
+#elif defined(HTOLE_DEFINED)
+#include <endian.h>
+#define LE_16 htole16
+#define LE_32 htole32
+#define LE_64 htole64
+#else
+#define LE_16(x) (x)
+#define LE_32(x) (x)
+#define LE_64(x) (x)
+#endif
 #include <fcntl.h>
 #include <string.h>
 #include <limits.h>
 #include <assert.h>
 #include <errno.h>
 
 #include "trousers/tss.h"
 #include "trousers_types.h"
 #include "tcs_int_literals.h"
 #include "tcsps.h"
@@ skipping 99 matching lines @@
 
         /* go to NUM_KEYS */
         rc = lseek(fd, TSSPS_NUM_KEYS_OFFSET, SEEK_SET);
         if (rc == ((off_t) - 1)) {
                 LogError("lseek: %s", strerror(errno));
                 return -1;
         }
 
         /* read the number of keys */
         rc = read(fd, &num_keys, sizeof(UINT32));
+        num_keys = LE_32(num_keys);
         if (rc == -1) {
                 LogError("read of %zd bytes: %s", sizeof(UINT32), strerror(errno));
                 return -1;
         } else if (rc == 0) {
                 /* This is the first key being written */
                 num_keys = 1;
                 version = 1;
 
                 /* seek to the PS version */
                 rc = lseek(fd, TSSPS_VERSION_OFFSET, SEEK_SET);
                 if (rc == ((off_t) - 1)) {
                         LogError("lseek: %s", strerror(errno));
                         return -1;
                 }
 
                 /* write out the version info byte */
                 if ((rc = write_data(fd, &version, sizeof(BYTE)))) {
                         LogError("%s", __FUNCTION__);
                         return rc;
                 }
 
                 rc = lseek(fd, TSSPS_NUM_KEYS_OFFSET, SEEK_SET);
                 if (rc == ((off_t) - 1)) {
                         LogError("lseek: %s", strerror(errno));
                         return -1;
                 }
 
+                num_keys = LE_32(num_keys);
                 if ((rc = write_data(fd, &num_keys, sizeof(UINT32)))) {
                         LogError("%s", __FUNCTION__);
                         return rc;
                 }
 
                 /* return the offset */
                 return (TSSPS_NUM_KEYS_OFFSET + sizeof(UINT32));
         }
 
         /* if there is a hole in the file we can write to, find it */
         offset = find_write_offset(pub_data_size, blob_size, vendor_data_size);
 
         if (offset != -1) {
                 /* we found a hole, seek to it and don't increment the # of keys on disk */
                 rc = lseek(fd, offset, SEEK_SET);
         } else {
                 /* we didn't find a hole, increment the number of keys on disk and seek
                  * to the end of the file
                  */
                 num_keys++;
 
                 /* go to the beginning */
                 rc = lseek(fd, TSSPS_NUM_KEYS_OFFSET, SEEK_SET);
                 if (rc == ((off_t) - 1)) {
                         LogError("lseek: %s", strerror(errno));
                         return -1;
                 }
-
+                num_keys = LE_32(num_keys);
                 if ((rc = write_data(fd, &num_keys, sizeof(UINT32)))) {
                         LogError("%s", __FUNCTION__);
                         return rc;
                 }
 
                 rc = lseek(fd, 0, SEEK_END);
         }
         if (rc == ((off_t) - 1)) {
                 LogError("lseek: %s", strerror(errno));
                 return -1;
@@ skipping 66 matching lines @@
                 return 0;
         }
 
         rc = read(fd, &num_keys, sizeof(UINT32));
         if (rc < 0) {
                 LogError("read of %zd bytes: %s", sizeof(UINT32), strerror(errno));
                 return 0;
         } else if ((unsigned)rc < sizeof(UINT32)) {
                 num_keys = 0;
         }
+        num_keys = LE_32(num_keys);
 
         return num_keys;
 }
 
 /*
  * count the number of valid keys in the cache
  */
 int
 get_num_keys()
 {
@@ skipping 109 matching lines @@
                 if ((rc = read_data(fd, (void *)&tmp->parent_uuid, sizeof(TSS_UUID)))) {
                         LogError("%s", __FUNCTION__);
                         goto err_exit;
                 }
 
                 /* pub data size */
                 if ((rc = read_data(fd, &tmp->pub_data_size, sizeof(UINT16)))) {
                         LogError("%s", __FUNCTION__);
                         goto err_exit;
                 }
+                tmp->pub_data_size = LE_16(tmp->pub_data_size);
 
-                DBG_ASSERT(tmp->pub_data_size <= 2048 && tmp->pub_data_size > 0);
+                //DBG_ASSERT(tmp->pub_data_size <= 2048 && tmp->pub_data_size > 0);
 
                 /* blob size */
                 if ((rc = read_data(fd, &tmp->blob_size, sizeof(UINT16)))) {
                         LogError("%s", __FUNCTION__);
                         goto err_exit;
                 }
-
+                tmp->blob_size = LE_16(tmp->blob_size);
                 DBG_ASSERT(tmp->blob_size <= 4096 && tmp->blob_size > 0);
 
                 /* vendor data size */
                 if ((rc = read_data(fd, &tmp->vendor_data_size, sizeof(UINT32)))) {
                         LogError("%s", __FUNCTION__);
                         goto err_exit;
                 }
+                tmp->vendor_data_size = LE_32(tmp->vendor_data_size);
 
                 /* cache flags */
                 if ((rc = read_data(fd, &tmp->flags, sizeof(UINT16)))) {
                         LogError("%s", __FUNCTION__);
                         goto err_exit;
                 }
+                tmp->flags = LE_16(tmp->flags);
 
 #ifdef TSS_DEBUG
                 if (tmp->flags & CACHE_FLAG_VALID)
                         valid_keys++;
 #endif
                 /* fast forward over the pub key */
                 offset = lseek(fd, tmp->pub_data_size, SEEK_CUR);
                 if (offset == ((off_t) - 1)) {
                         LogError("lseek: %s", strerror(errno));
                         rc = -1;
@@ skipping 74 matching lines @@
         do {
                 tmp_next = tmp->next;
                 free(tmp);
                 tmp = tmp_next;
         } while (tmp);
 
         MUTEX_UNLOCK(disk_cache_lock);
 
         return 0;
 }