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

src/tcs/tcs_auth_mgr.c

 
 /*
  * Licensed Materials - Property of IBM
  *
  * trousers - An open source TCG Software Stack
  *
  * (C) Copyright International Business Machines Corp. 2004-2006
  *
  */
 
@@ skipping 10 matching lines @@
 #include "capabilities.h"
 #include "tcslog.h"
 #include "tcsd_wrap.h"
 #include "tcsd.h"
 #include "auth_mgr.h"
 #include "req_mgr.h"
 
 
 MUTEX_DECLARE_EXTERN(tcsp_lock);
 
-
 /* Note: The after taking the auth_mgr_lock in any of the functions below, the
  * mem_cache_lock cannot be taken without risking a deadlock. So, the auth_mgr
  * functions must be "self-contained" wrt locking */
 
 /* no locking done in init since its called by only a single thread */
 TSS_RESULT
 auth_mgr_init()
 {
         memset(&auth_mgr, 0, sizeof(struct _auth_mgr));
 
@@ skipping 31 matching lines @@
 
         free(auth_mgr.overflow);
         free(auth_mgr.auth_mapper);
 
         return TSS_SUCCESS;
 }
 
 TSS_RESULT
 auth_mgr_save_ctx(TCS_CONTEXT_HANDLE hContext)
 {
-        TSS_RESULT result;
+       TSS_RESULT result = TSS_SUCCESS;
         UINT32 i;
 
         for (i = 0; i < auth_mgr.auth_mapper_size; i++) {
                 if (auth_mgr.auth_mapper[i].full == TRUE &&
                     auth_mgr.auth_mapper[i].swap == NULL &&
                     auth_mgr.auth_mapper[i].tcs_ctx != hContext) {
-
                         LogDebug("Calling TPM_SaveAuthContext for TCS CTX %x. Swapping out: TCS %x "
                                  "TPM %x", hContext, auth_mgr.auth_mapper[i].tcs_ctx,
                                  auth_mgr.auth_mapper[i].tpm_handle);
 
                         if ((result = TPM_SaveAuthContext(auth_mgr.auth_mapper[i].tpm_handle,
                                                           &auth_mgr.auth_mapper[i].swap_size,
                                                           &auth_mgr.auth_mapper[i].swap))) {
                                 LogDebug("TPM_SaveAuthContext failed: 0x%x", result);
                                 return result;
                         }
-
-                        /* XXX should there be a break here? */
+                       break;
                 }
         }
 
-        return TSS_SUCCESS;
+       return result;
 }
 
 /* if there's a TCS context waiting to get auth, wake it up or swap it in */
 void
 auth_mgr_swap_in()
 {
         if (auth_mgr.overflow[auth_mgr.of_tail] != NULL) {
-                LogDebug("waking up thread %zd, auth slot has opened", THREAD_ID);
+                LogDebug("waking up thread %lddd, auth slot has opened", THREAD_ID);
                 /* wake up the next sleeping thread in order and increment tail */
                 COND_SIGNAL(auth_mgr.overflow[auth_mgr.of_tail]);
                 auth_mgr.overflow[auth_mgr.of_tail] = NULL;
                 auth_mgr.of_tail = (auth_mgr.of_tail + 1) % auth_mgr.overflow_size;
         } else {
                 /* else nobody needs to be swapped in, so continue */
                 LogDebug("no threads need to be signaled.");
         }
 }
 
@@ skipping 20 matching lines @@
         if (auth_mgr.sleeping_threads == (tcsd_options.num_threads - 1)) {
                 LogError("auth mgr failing: too many threads already waiting");
                 LogTPMERR(TCPA_E_RESOURCES, __FILE__, __LINE__);
                 return TCPA_E_RESOURCES;
         }
 
         if (auth_mgr.overflow[auth_mgr.of_head] == NULL) {
                 auth_mgr.overflow[auth_mgr.of_head] = cond;
                 auth_mgr.of_head = (auth_mgr.of_head + 1) % auth_mgr.overflow_size;
                 /* go to sleep */
-                LogDebug("thread %zd going to sleep until auth slot opens", THREAD_ID);
+                LogDebug("thread %lddd going to sleep until auth slot opens", THREAD_ID);
                 auth_mgr.sleeping_threads++;
                 COND_WAIT(cond, &tcsp_lock);
                 auth_mgr.sleeping_threads--;
         } else if (auth_mgr.overflow_size + TSS_DEFAULT_OVERFLOW_AUTHS < UINT_MAX) {
                 COND_VAR **tmp = auth_mgr.overflow;
 
                 LogDebugFn("Table of sleeping threads is full (%hu), growing to %hu entries",
                            auth_mgr.sleeping_threads,
                            auth_mgr.overflow_size + TSS_DEFAULT_OVERFLOW_AUTHS);
 
@@ skipping 10 matching lines @@
 
                 LogDebugFn("Success.");
                 memcpy(auth_mgr.overflow, tmp, auth_mgr.sleeping_threads * sizeof(COND_VAR *));
                 free(tmp);
 
                 /* XXX This could temporarily wake threads up out of order */
                 auth_mgr.of_head = auth_mgr.sleeping_threads;
                 auth_mgr.of_tail = 0;
                 auth_mgr.overflow[auth_mgr.of_head] = cond;
                 auth_mgr.of_head = (auth_mgr.of_head + 1) % auth_mgr.overflow_size;
-                LogDebug("thread %zd going to sleep until auth slot opens", THREAD_ID);
+                LogDebug("thread %lddd going to sleep until auth slot opens", THREAD_ID);
                 auth_mgr.sleeping_threads++;
                 COND_WAIT(cond, &tcsp_lock);
                 auth_mgr.sleeping_threads--;
         } else {
                 LogError("Auth table overflow is full (%u entries), some will fail.",
                          auth_mgr.overflow_size);
                 return TCSERR(TSS_E_INTERNAL_ERROR);
         }
 
         return TSS_SUCCESS;
@@ skipping 14 matching lines @@
                                  * blob */
                                 free(auth_mgr.auth_mapper[i].swap);
                                 auth_mgr.auth_mapper[i].swap = NULL;
                                 auth_mgr.auth_mapper[i].swap_size = 0;
                         } else {
                                 result = TCSP_FlushSpecific_Common(auth_mgr.auth_mapper[i].tpm_handle,
                                                                    TPM_RT_AUTH);
 
                                 /* Ok, probably dealing with a 1.1 TPM */
                                 if (result == TPM_E_BAD_ORDINAL)
-                                      result = internal_TerminateHandle(
-                                                                        auth_mgr.auth_mapper[i].tpm_handle);
+                                       result = internal_TerminateHandle(
+                                           auth_mgr.auth_mapper[i].tpm_handle);
 
                                 if (result == TCPA_E_INVALID_AUTHHANDLE) {
                                         LogDebug("Tried to close an invalid auth handle: %x",
                                                  auth_mgr.auth_mapper[i].tpm_handle);
                                 } else if (result != TCPA_SUCCESS) {
                                         LogDebug("TPM_TerminateHandle returned %d", result);
                                 }
                         }
+                       /* clear the slot */
                         auth_mgr.open_auth_sessions--;
                         auth_mgr.auth_mapper[i].full = FALSE;
+                       auth_mgr.auth_mapper[i].tpm_handle = 0;
+                       auth_mgr.auth_mapper[i].tcs_ctx = 0;
                         LogDebug("released auth for TCS %x TPM %x", tcs_handle,
-                                 auth_mgr.auth_mapper[i].tpm_handle);
+                               auth_mgr.auth_mapper[i].tpm_handle);
+
                         auth_mgr_swap_in();
                 }
         }
 
         return TSS_SUCCESS;
 }
 
 void
 auth_mgr_release_auth(TPM_AUTH *auth0, TPM_AUTH *auth1, TCS_CONTEXT_HANDLE tcs_handle)
 {
@@ skipping 12 matching lines @@
                              TSS_BOOL cont)
 {
         UINT32 i;
         TSS_RESULT result = TSS_SUCCESS;
 
         for (i = 0; i < auth_mgr.auth_mapper_size; i++) {
                 if (auth_mgr.auth_mapper[i].full == TRUE &&
                     auth_mgr.auth_mapper[i].tpm_handle == tpm_auth_handle &&
                     auth_mgr.auth_mapper[i].tcs_ctx == tcs_handle) {
                         if (!cont) {
-                                /* Only termininate when not in use anymore */
-                                result = TCSP_FlushSpecific_Common(auth_mgr.auth_mapper[i].tpm_handle,
-                                                                   TPM_RT_AUTH);
+                               /*
+                                * This function should not be necessary, but
+                                * if the main operation resulted in an error,
+                                * the TPM may still hold the auth handle
+                                * and it must be freed.  Most of the time
+                                * this call will result in TPM_E_INVALID_AUTHHANDLE
+                                * error which can be ignored.
+                                */
+                               result = TCSP_FlushSpecific_Common(
+                                   auth_mgr.auth_mapper[i].tpm_handle,
+                                   TPM_RT_AUTH);
 
                                 /* Ok, probably dealing with a 1.1 TPM */
                                 if (result == TPM_E_BAD_ORDINAL)
-                                      result = internal_TerminateHandle(
-                                                                        auth_mgr.auth_mapper[i].tpm_handle);
+                                       result = internal_TerminateHandle(
+                                           auth_mgr.auth_mapper[i].tpm_handle);
 
                                 if (result == TCPA_E_INVALID_AUTHHANDLE) {
                                         LogDebug("Tried to close an invalid auth handle: %x",
                                                  auth_mgr.auth_mapper[i].tpm_handle);
                                 } else if (result != TCPA_SUCCESS) {
                                         LogDebug("TPM_TerminateHandle returned %d", result);
                                 }
+
+                               if (result == TPM_SUCCESS) {
+                                       LogDebug("released auth for TCS %x TPM %x",
+                                                auth_mgr.auth_mapper[i].tcs_ctx, tpm_auth_handle);
+                               }
+                               /*
+                                * Mark it as released, the "cont" flag indicates
+                                * that it is no longer needed.
+                                */
+                               auth_mgr.open_auth_sessions--;
+                               auth_mgr.auth_mapper[i].full = FALSE;
+                               auth_mgr.auth_mapper[i].tpm_handle = 0;
+                               auth_mgr.auth_mapper[i].tcs_ctx = 0;
+                               auth_mgr_swap_in();
                         }
-                        auth_mgr.open_auth_sessions--;
-                        auth_mgr.auth_mapper[i].full = FALSE;
-                        LogDebug("released auth for TCS %x TPM %x",
-                                 auth_mgr.auth_mapper[i].tcs_ctx, tpm_auth_handle);
-                        auth_mgr_swap_in();
+                       /* If the cont flag is TRUE, we have to keep the handle */
                 }
         }
 
         return result;
 }
 
 TSS_RESULT
 auth_mgr_check(TCS_CONTEXT_HANDLE tcsContext, TPM_AUTHHANDLE *tpm_auth_handle)
 {
         UINT32 i;
@@ skipping 63 matching lines @@
                         auth_mgr.auth_mapper[i].tcs_ctx = tcsContext;
                         auth_mgr.auth_mapper[i].full = TRUE;
                         auth_mgr.open_auth_sessions++;
                         LogDebug("added auth for TCS %x TPM %x", tcsContext, tpm_auth_handle);
 
                         return TSS_SUCCESS;
                 }
         }
 
 
-        LogDebugFn("Thread %zd growing the auth table to %u entries", THREAD_ID,
+        LogDebugFn("Thread %ld growing the auth table to %u entries", THREAD_ID,
                    auth_mgr.auth_mapper_size + TSS_DEFAULT_AUTH_TABLE_SIZE);
 
         auth_mgr.auth_mapper = calloc(auth_mgr.auth_mapper_size +
                                       TSS_DEFAULT_AUTH_TABLE_SIZE, sizeof(struct auth_map));
         if (auth_mgr.auth_mapper == NULL) {
                 auth_mgr.auth_mapper = tmp;
                 return TCSERR(TSS_E_OUTOFMEMORY);
         } else {
                 memcpy(auth_mgr.auth_mapper, tmp,
                                 auth_mgr.auth_mapper_size * sizeof(struct auth_map));
@@ skipping 174 matching lines @@
 
         result = UnloadBlob_Header(txBlob, &trash);
 
         if (!result) {
                 offset = 10;
                 UnloadBlob_UINT32(&offset, handle, txBlob);
         }
 
         return result;
 }
-