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

src/tspi/ps/tspps.c

 
 /*
  * Licensed Materials - Property of IBM
  *
  * trousers - An open source TCG Software Stack
  *
  * (C) Copyright International Business Machines Corp. 2004-2006
  *
  */
 
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
 #include <pwd.h>
 #include <sys/types.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <assert.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <netdb.h>
+#if defined (HAVE_BYTEORDER_H)
+#include <sys/byteorder.h>
+#elif defined(HAVE_ENDIAN_H)
+#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 "trousers/tss.h"
 #include "trousers/trousers.h"
 #include "trousers_types.h"
 #include "tcs_tsp.h"
 #include "spi_utils.h"
 #include "tspps.h"
 #include "tsplog.h"
 
 static int user_ps_fd = -1;
 static MUTEX_DECLARE_INIT(user_ps_lock);
 #if (defined (__FreeBSD__) || defined (__OpenBSD__))
 static MUTEX_DECLARE_INIT(user_ps_path);
 #endif
+#if defined (SOLARIS)
+static struct flock fl = {
+       0,
+       0,
+       0,
+       0,
+       0,
+       0,
+       {0, 0, 0, 0}
+};
+#endif
 
 
 /*
  * Determine the default path to the persistent storage file and create it if it doesn't exist.
  */
 TSS_RESULT
 get_user_ps_path(char **file)
 {
         TSS_RESULT result;
         char *file_name = NULL, *home_dir = NULL;
         struct passwd *pwp;
-#if (defined (__linux) || defined (linux))
+#if (defined (__linux) || defined (linux) || defined(__GLIBC__))
         struct passwd pw;
 #endif
         struct stat stat_buf;
         char buf[PASSWD_BUFSIZE];
         uid_t euid;
         int rc;
 
         if ((file_name = getenv("TSS_USER_PS_FILE"))) {
                 *file = strdup(file_name);
                 return (*file) ? TSS_SUCCESS : TSPERR(TSS_E_OUTOFMEMORY);
         }
 #if (defined (__FreeBSD__) || defined (__OpenBSD__))
         MUTEX_LOCK(user_ps_path);
 #endif
 
         euid = geteuid();
 
+#if defined (SOLARIS)
+        /*
+         * Solaris keeps user PS in a local directory instead of
+         * in the user's home directory, which may be shared
+         * by multiple systems.
+         *
+         * The directory path on Solaris is /var/tpm/userps/[EUID]/
+         */
+        rc = snprintf(buf, sizeof (buf), "%s/%d", TSS_USER_PS_DIR, euid);
+#else
         setpwent();
         while (1) {
-#if (defined (__linux) || defined (linux))
+#if (defined (__linux) || defined (linux) || defined(__GLIBC__))
                 rc = getpwent_r(&pw, buf, PASSWD_BUFSIZE, &pwp);
                 if (rc) {
                         LogDebugFn("USER PS: Error getting path to home directory: getpwent_r: %s",
                                    strerror(rc));
                         endpwent();
                         return TSPERR(TSS_E_INTERNAL_ERROR);
                 }
 
 #elif (defined (__FreeBSD__) || defined (__OpenBSD__))
                 if ((pwp = getpwent()) == NULL) {
                         LogDebugFn("USER PS: Error getting path to home directory: getpwent: %s",
                                    strerror(rc));
                         endpwent();
                         MUTEX_UNLOCK(user_ps_path);
                         return TSPERR(TSS_E_INTERNAL_ERROR);
                 }
 #endif
                 if (euid == pwp->pw_uid) {
                         home_dir = strdup(pwp->pw_dir);
                         break;
                 }
         }
         endpwent();
 
         if (!home_dir)
                 return TSPERR(TSS_E_OUTOFMEMORY);
 
         /* Tack on TSS_USER_PS_DIR and see if it exists */
-        rc = snprintf(buf, PASSWD_BUFSIZE, "%s/%s", home_dir, TSS_USER_PS_DIR);
-        if (rc == PASSWD_BUFSIZE) {
+        rc = snprintf(buf, sizeof (buf), "%s/%s", home_dir, TSS_USER_PS_DIR);
+#endif /* SOLARIS */
+        if (rc == sizeof (buf)) {
                 LogDebugFn("USER PS: Path to file too long! (> %d bytes)", PASSWD_BUFSIZE);
                 result = TSPERR(TSS_E_INTERNAL_ERROR);
                 goto done;
         }
 
         errno = 0;
         if ((rc = stat(buf, &stat_buf)) == -1) {
                 if (errno == ENOENT) {
                         errno = 0;
-                        /* Create the base directory, $HOME/.trousers */
+                        /* Create the user's ps directory if it is not there. */
                         if ((rc = mkdir(buf, 0700)) == -1) {
                                 LogDebugFn("USER PS: Error creating dir: %s: %s", buf,
                                            strerror(errno));
                                 result = TSPERR(TSS_E_INTERNAL_ERROR);
                                 goto done;
                         }
                 } else {
                         LogDebugFn("USER PS: Error stating dir: %s: %s", buf, strerror(errno));
                         result = TSPERR(TSS_E_INTERNAL_ERROR);
                         goto done;
                 }
         }
 
         /* Directory exists or has been created, return the path to the file */
-        rc = snprintf(buf, PASSWD_BUFSIZE, "%s/%s/%s", home_dir, TSS_USER_PS_DIR,
+#if defined (SOLARIS)
+        rc = snprintf(buf, sizeof (buf), "%s/%d/%s", TSS_USER_PS_DIR, euid,
                       TSS_USER_PS_FILE);
-        if (rc == PASSWD_BUFSIZE) {
-                LogDebugFn("USER PS: Path to file too long! (> %d bytes)", PASSWD_BUFSIZE);
+#else
+        rc = snprintf(buf, sizeof (buf), "%s/%s/%s", home_dir, TSS_USER_PS_DIR,
+                      TSS_USER_PS_FILE);
+#endif
+        if (rc == sizeof (buf)) {
+                LogDebugFn("USER PS: Path to file too long! (> %d bytes)", sizeof (buf));
         } else
                 *file = strdup(buf);
 
         result = (*file) ? TSS_SUCCESS : TSPERR(TSS_E_OUTOFMEMORY);
 done:
         free(home_dir);
         return result;
 }
 
 TSS_RESULT
 get_file(int *fd)
 {
         TSS_RESULT result;
         int rc = 0;
         char *file_name = NULL;
 
         MUTEX_LOCK(user_ps_lock);
 
         /* check the global file handle first.  If it exists, lock it and return */
         if (user_ps_fd != -1) {
+#if defined (SOLARIS)
+                fl.l_type = F_WRLCK;
+                if ((rc = fcntl(user_ps_fd, F_SETLKW, &fl))) {
+#else
                 if ((rc = flock(user_ps_fd, LOCK_EX))) {
+#endif /* SOLARIS */
                         LogDebug("USER PS: failed to lock file: %s", strerror(errno));
                         MUTEX_UNLOCK(user_ps_lock);
                         return TSPERR(TSS_E_INTERNAL_ERROR);
                 }
-
                 *fd = user_ps_fd;
                 return TSS_SUCCESS;
         }
 
         /* open and lock the file */
         if ((result = get_user_ps_path(&file_name))) {
                 LogDebugFn("USER PS: error getting file path");
                 MUTEX_UNLOCK(user_ps_lock);
                 return result;
         }
 
         user_ps_fd = open(file_name, O_CREAT|O_RDWR, 0600);
         if (user_ps_fd < 0) {
                 LogDebug("USER PS: open of %s failed: %s", file_name, strerror(errno));
                 free(file_name);
                 MUTEX_UNLOCK(user_ps_lock);
                 return TSPERR(TSS_E_INTERNAL_ERROR);
         }
-
+#if defined (SOLARIS)
+        fl.l_type = F_WRLCK;
+        if ((rc = fcntl(user_ps_fd, F_SETLKW, &fl))) {
+#else
         if ((rc = flock(user_ps_fd, LOCK_EX))) {
+#endif /* SOLARIS */
                 LogDebug("USER PS: failed to get lock of %s: %s", file_name, strerror(errno));
                 free(file_name);
                 close(user_ps_fd);
                 user_ps_fd = -1;
                 MUTEX_UNLOCK(user_ps_lock);
                 return TSPERR(TSS_E_INTERNAL_ERROR);
         }
 
         *fd = user_ps_fd;
         free(file_name);
         return TSS_SUCCESS;
 }
 
 int
 put_file(int fd)
 {
         int rc = 0;
 
         fsync(fd);
 
         /* release the file lock */
+#if defined (SOLARIS)
+        fl.l_type = F_UNLCK;
+        if ((rc = fcntl(fd, F_SETLKW, &fl))) {
+#else
         if ((rc = flock(fd, LOCK_UN))) {
+#endif /* SOLARIS */
                 LogDebug("USER PS: failed to unlock file: %s", strerror(errno));
                 rc = -1;
         }
 
         MUTEX_UNLOCK(user_ps_lock);
         return rc;
 }
 
 void
 psfile_close(int fd)
@@ skipping 154 matching lines @@
         if (rc == ((off_t)-1)) {
                 LogDebug("lseek: %s", strerror(errno));
                 return TSPERR(TSS_E_INTERNAL_ERROR);
         }
 
         rc = read(fd, &num_keys, sizeof(UINT32));
         if (rc != sizeof(UINT32)) {
                 LogDebug("read of %zd bytes: %s", sizeof(UINT32), strerror(errno));
                 return TSPERR(TSS_E_INTERNAL_ERROR);
         }
+        num_keys = LE_32(num_keys);
 
         if (increment)
                 num_keys++;
         else
                 num_keys--;
 
         rc = lseek(fd, TSSPS_NUM_KEYS_OFFSET, SEEK_SET);
         if (rc == ((off_t)-1)) {
                 LogDebug("lseek: %s", strerror(errno));
                 return TSPERR(TSS_E_INTERNAL_ERROR);
         }
 
+        num_keys = LE_32(num_keys);
         if ((result = write_data(fd, (void *)&num_keys, sizeof(UINT32)))) {
                 LogDebug("%s", __FUNCTION__);
                 return result;
         }
 
         return TSS_SUCCESS;
 }
 
 /* Write the initial header (number of keys and PS version) to initialize a new file */
 TSS_RESULT
@@ skipping 101 matching lines @@
                 goto done;
         }
 
         /* [TSS_UUID uuid_parent0    ] yes */
         if ((result = write_data(fd, (void *)parent_uuid, sizeof(TSS_UUID)))) {
                 LogDebug("%s", __FUNCTION__);
                 goto done;
         }
 
         /* [UINT16   pub_data_size0  ] yes */
+        pub_key_size = LE_16(pub_key_size);
         if ((result = write_data(fd, &pub_key_size, sizeof(UINT16)))) {
                 LogDebug("%s", __FUNCTION__);
                 goto done;
         }
+        pub_key_size = LE_16(pub_key_size);
 
         /* [UINT16   blob_size0      ] yes */
+        key_blob_size = LE_16(key_blob_size);
         if ((result = write_data(fd, &key_blob_size, sizeof(UINT16)))) {
                 LogDebug("%s", __FUNCTION__);
                 goto done;
         }
+        key_blob_size = LE_16(key_blob_size);
 
         /* [UINT32   vendor_data_size0 ] yes */
         if ((result = write_data(fd, &zero, sizeof(UINT32)))) {
                 LogDebug("%s", __FUNCTION__);
                 goto done;
         }
 
         /* [UINT16   cache_flags0    ] yes */
+        cache_flags = LE_16(cache_flags);
         if ((result = write_data(fd, &cache_flags, sizeof(UINT16)))) {
                 LogDebug("%s", __FUNCTION__);
                 goto done;
         }
+        cache_flags = LE_16(cache_flags);
 
         /* [BYTE[]   pub_data0       ] no */
         if ((result = write_data(fd, (void *)key.pubKey.key, pub_key_size))) {
                 LogDebug("%s", __FUNCTION__);
                 goto done;
         }
 
         /* [BYTE[]   blob0           ] no */
         if ((result = write_data(fd, (void *)key_blob, key_blob_size))) {
                 LogDebug("%s", __FUNCTION__);
@@ skipping 145 matching lines @@
                 if ((result = read_data(fd, &tmp[i].parent_uuid, sizeof(TSS_UUID)))) {
                         LogDebug("%s", __FUNCTION__);
                         goto err_exit;
                 }
 
                 /* pub data size */
                 if ((result = read_data(fd, &tmp[i].pub_data_size, sizeof(UINT16)))) {
                         LogDebug("%s", __FUNCTION__);
                         goto err_exit;
                 }
+                tmp[i].pub_data_size = LE_16(tmp[i].pub_data_size);
 
                 DBG_ASSERT(tmp[i].pub_data_size <= 2048);
 
                 /* blob size */
                 if ((result = read_data(fd, &tmp[i].blob_size, sizeof(UINT16)))) {
                         LogDebug("%s", __FUNCTION__);
                         goto err_exit;
                 }
+                tmp[i].blob_size = LE_16(tmp[i].blob_size);
 
                 DBG_ASSERT(tmp[i].blob_size <= 4096);
 
                 /* vendor data size */
                 if ((result = read_data(fd, &tmp[i].vendor_data_size, sizeof(UINT32)))) {
                         LogDebug("%s", __FUNCTION__);
                         goto err_exit;
                 }
+                tmp[i].vendor_data_size = LE_32(tmp[i].vendor_data_size);
 
                 /* cache flags */
                 if ((result = read_data(fd, &tmp[i].flags, sizeof(UINT16)))) {
                         LogDebug("%s", __FUNCTION__);
                         goto err_exit;
                 }
+                tmp[i].flags = LE_16(tmp[i].flags);
 
                 /* fast forward over the pub key */
                 offset = lseek(fd, tmp[i].pub_data_size, SEEK_CUR);
                 if (offset == ((off_t)-1)) {
                         LogDebug("lseek: %s", strerror(errno));
                         result = TSPERR(TSS_E_INTERNAL_ERROR);
                         goto err_exit;
                 }
 
                 /* fast forward over the blob */
@@ skipping 304 matching lines @@
         }
 
         rc = read(fd, &num_keys, sizeof(UINT32));
         if (rc < 0) {
                 LogDebug("read of %zd bytes: %s", sizeof(UINT32), strerror(errno));
                 return 0;
         } else if ((unsigned)rc < sizeof(UINT32)) {
                 num_keys = 0;
         }
 
+        /* The system PS file is written in little-endian */
+        num_keys = LE_32(num_keys);
         return num_keys;
 }
 
 /*
  * disk store format:
  *
  * TrouSerS 0.2.1+
  * Version 1:                  cached?
  * [BYTE     PS version = '\1']
  * [UINT32   num_keys_on_disk ]
@@ skipping 58 matching lines @@
                                 LogDebug("lseek: %s", strerror(errno));
                                 return TSPERR(TSS_E_INTERNAL_ERROR);
                         }
                 }
 
                 /* pub data size */
                 if ((result = read_data(fd, &c->pub_data_size, sizeof(UINT16)))) {
                         LogDebug("%s", __FUNCTION__);
                         return result;
                 }
-
+                c->pub_data_size = LE_16(c->pub_data_size);
                 DBG_ASSERT(c->pub_data_size <= 2048 && c->pub_data_size > 0);
 
                 /* blob size */
                 if ((result = read_data(fd, &c->blob_size, sizeof(UINT16)))) {
                         LogDebug("%s", __FUNCTION__);
                         return result;
                 }
-
+                c->blob_size = LE_16(c->blob_size); 
                 DBG_ASSERT(c->blob_size <= 4096 && c->blob_size > 0);
 
                 /* vendor data size */
                 if ((result = read_data(fd, &c->vendor_data_size, sizeof(UINT32)))) {
                         LogDebug("%s", __FUNCTION__);
                         return result;
                 }
+                c->vendor_data_size = LE_32(c->vendor_data_size); 
 
                 /* cache flags */
                 if ((result = read_data(fd, &c->flags, sizeof(UINT16)))) {
                         LogDebug("%s", __FUNCTION__);
                         return result;
                 }
+                c->flags = LE_16(c->flags); 
 
                 /* fast forward over the pub key */
                 offset = lseek(fd, c->pub_data_size, SEEK_CUR);
                 if (offset == ((off_t)-1)) {
                         LogDebug("lseek: %s", strerror(errno));
                         return TSPERR(TSS_E_INTERNAL_ERROR);
                 }
 
                 /* fast forward over the blob */
                 offset = lseek(fd, c->blob_size, SEEK_CUR);
@@ skipping 47 matching lines @@
                         LogDebug("%s", __FUNCTION__);
                         return result;
                 }
 
                 /* pub data size */
                 if ((result = read_data(fd, &c->pub_data_size, sizeof(UINT16)))) {
                         LogDebug("%s", __FUNCTION__);
                         return result;
                 }
 
+                c->pub_data_size = LE_16(c->pub_data_size);
                 DBG_ASSERT(c->pub_data_size <= 2048 && c->pub_data_size > 0);
 
                 /* blob size */
                 if ((result = read_data(fd, &c->blob_size, sizeof(UINT16)))) {
                         LogDebug("%s", __FUNCTION__);
                         return result;
                 }
 
+                c->blob_size = LE_16(c->blob_size);
                 DBG_ASSERT(c->blob_size <= 4096 && c->blob_size > 0);
 
                 /* vendor data size */
                 if ((result = read_data(fd, &c->vendor_data_size, sizeof(UINT32)))) {
                         LogDebug("%s", __FUNCTION__);
                         return result;
                 }
+                c->vendor_data_size = LE_32(c->vendor_data_size);
 
                 /* cache flags */
                 if ((result = read_data(fd, &c->flags, sizeof(UINT16)))) {
                         LogDebug("%s", __FUNCTION__);
                         return result;
                 }
+                c->flags = LE_16(c->flags);
 
                 if (c->pub_data_size == pub_size) {
                         /* read in the pub key */
                         if ((result = read_data(fd, blob, c->pub_data_size))) {
                                 LogDebug("%s", __FUNCTION__);
                                 return result;
                         }
 
                         if (!memcmp(blob, pub, pub_size))
                                 break;
                 }
 
                 /* fast forward over the blob */
                 offset = lseek(fd, c->blob_size, SEEK_CUR);
                 if (offset == ((off_t)-1)) {
                         LogDebug("lseek: %s", strerror(errno));
                         return TSPERR(TSS_E_INTERNAL_ERROR);
                 }
 
                 /* ignore vendor data */
         }
 
         return TSS_SUCCESS;
 }