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

src/tspi/tsp_context_mem.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 <string.h>
 
 #include "trousers/tss.h"
 #include "trousers_types.h"
 #include "spi_utils.h"
 #include "capabilities.h"
 #include "memmgr.h"
 #include "tsplog.h"
 #include "obj.h"
 
+static struct memTable *
+__tspi_createTable()
+{
+        struct memTable *table = NULL;
+        /*
+         * No table has yet been created to hold the memory allocations of
+         * this context, so we need to create one
+         */
+        table = calloc(1, sizeof(struct memTable));
+        if (table == NULL) {
+                LogError("malloc of %zd bytes failed.", sizeof(struct memTable));
+                return NULL;
+        }
+        return (table);
+}
+
 /* caller needs to lock memtable lock */
 struct memTable *
 getTable(TSS_HCONTEXT tspContext)
 {
         struct memTable *tmp;
 
         for (tmp = SpiMemoryTable; tmp; tmp = tmp->nextTable)
                 if (tmp->tspContext == tspContext)
                         return tmp;
 
         return NULL;
 }
 
+/* caller needs to lock memtable lock */
+static void
+__tspi_addTable(struct memTable *new)
+{
+        struct memTable *tmp = SpiMemoryTable;
+
+        /* base case, this is the first table */
+        if (SpiMemoryTable == NULL) {
+                SpiMemoryTable = new;
+                return;
+        }
+
+        /* else add @new onto the end */
+        for (; tmp; tmp = tmp->nextTable)
+                if (tmp->nextTable == NULL) {
+                        tmp->nextTable = new;
+                        break;
+                }
+}
+
 /* caller needs to lock memtable lock and be sure the context mem slot for
  * @tspContext exists before calling.
  */
 void
 __tspi_addEntry(TSS_HCONTEXT tspContext, struct memEntry *new)
 {
         struct memTable *tmp = getTable(tspContext);
-        struct memEntry *tmp_entry = tmp->entries;
+        struct memEntry *tmp_entry;
+
+        if (tmp == NULL) {
+                if ((tmp = __tspi_createTable()) == NULL)
+                        return;
+                tmp->tspContext = tspContext;
+                __tspi_addTable(tmp);
+        }
+
+        tmp_entry = tmp->entries;
 
         if (tmp->entries == NULL) {
                 tmp->entries = new;
                 return;
         }
 
         /* else tack @new onto the end */
         for (; tmp_entry; tmp_entry = tmp_entry->nextEntry) {
                 if (tmp_entry->nextEntry == NULL) {
                         tmp_entry->nextEntry = new;
                         break;
                 }
         }
 }
 
 /* caller needs to lock memtable lock */
-void
-__tspi_addTable(struct memTable *new)
-{
-        struct memTable *tmp = SpiMemoryTable;
-
-        /* base case, this is the first table */
-        if (SpiMemoryTable == NULL) {
-                SpiMemoryTable = new;
-                return;
-        }
-
-        /* else add @new onto the end */
-        for (; tmp; tmp = tmp->nextTable)
-                if (tmp->nextTable == NULL) {
-                        tmp->nextTable = new;
-                        break;
-                }
-}
-
-/* caller needs to lock memtable lock */
 TSS_RESULT
 __tspi_freeTable(TSS_HCONTEXT tspContext)
 {
         struct memTable *prev = NULL, *index = NULL, *next = NULL;
         struct memEntry *entry = NULL, *entry_next = NULL;
 
         for(index = SpiMemoryTable; index; index = index->nextTable) {
                 next = index->nextTable;
                 if (index->tspContext == tspContext) {
                         for (entry = index->entries; entry; entry = entry_next) {
@@ skipping 68 matching lines @@
 void *
 calloc_tspi(TSS_HCONTEXT tspContext, UINT32 howMuch)
 {
         struct memTable *table = NULL;
         struct memEntry *newEntry = NULL;
 
         MUTEX_LOCK(memtable_lock);
 
         table = getTable(tspContext);
         if (table == NULL) {
-                /* no table has yet been created to hold the memory allocations of
-                 * this context, so we need to create one
-                 */
-                table = calloc(1, sizeof(struct memTable));
-                if (table == NULL) {
-                        LogError("malloc of %zd bytes failed.", sizeof(struct memTable));
+                if ((table = __tspi_createTable()) == NULL) {
                         MUTEX_UNLOCK(memtable_lock);
                         return NULL;
                 }
                 table->tspContext = tspContext;
                 __tspi_addTable(table);
         }
 
         newEntry = calloc(1, sizeof(struct memEntry));
         if (newEntry == NULL) {
                 LogError("malloc of %zd bytes failed.", sizeof(struct memEntry));
@@ skipping 44 matching lines @@
                 return TSPERR(TSS_E_INVALID_RESOURCE);
         }
 
         /* just free one entry */
         result = __tspi_freeEntry(index, memPointer);
 
         MUTEX_UNLOCK(memtable_lock);
 
         return result;
 }