Upgrade to tpm-emulator version 0.7.

tpm/tpm_capability.c

-/* Software-Based Trusted Platform Module (TPM) Emulator for Linux
- * Copyright (C) 2004 Mario Strasser <mast@gmx.net>,
- *                    Swiss Federal Institute of Technology (ETH) Zurich,
- *               2006, 2008 Heiko Stamer <stamer@gaos.org>
+/* Software-based Trusted Platform Module (TPM) Emulator
+ * Copyright (C) 2004-2010 Mario Strasser <mast@gmx.net>
+ *               2005-2008 Heiko Stamer <stamer@gaos.org>
  *
  * This module is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published
  * by the Free Software Foundation; either version 2 of the License,
  * or (at your option) any later version.
  *
  * This module is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
- * $Id$
+ * $Id: tpm_capability.c 407 2010-02-19 11:14:52Z mast $
  */
 
 #include "tpm_emulator.h"
 #include "tpm_commands.h"
 #include "tpm_marshalling.h"
 #include "tpm_data.h"
 #include "tpm_handles.h"
 
 /*
  * The GetCapability Commands ([TPM_Part3], Section 7)
@@ skipping 320 matching lines @@
           list.handle[i] = INDEX_TO_COUNTER_HANDLE(i);
         }
       break;
     case TPM_RT_CONTEXT:
       debug("[TPM_RT_CONTEXT]");
       for (i = 0; i < TPM_MAX_SESSION_LIST; i++)
         if (tpmData.stany.data.contextList[i] != 0) {
           list.loaded++;
           list.handle[i] = tpmData.stany.data.contextList[i];
         }
+      break;
     default:
       return TPM_BAD_MODE;
   }
   /* marshal handle list */
   len = *respSize = 2 + list.loaded * 4;
   ptr = *resp = tpm_malloc(len);
   if (ptr == NULL || tpm_marshal_TPM_KEY_HANDLE_LIST(&ptr, &len, &list)) {
     tpm_free(*resp);
     return TPM_FAIL;
   }
@@ skipping 512 matching lines @@
 }
 
 static TPM_RESULT set_perm_data(UINT32 subCap, BYTE *setValue,
                                 UINT32 setValueSize, BOOL ownerAuth,
                                 BOOL deactivated, BOOL disabled)
 {
   TPM_CMK_DELEGATE del;
   TPM_NONCE nonce;
   switch (subCap) {
 
-#ifdef TPM_ENABLE_PRNG_STATE_SETTING
     case 16:
-      if (setValueSize != sizeof(tpmData.permanent.data.rngState))
+      if (tpmConf & TPM_CONF_ALLOW_PRNG_STATE_SETTING) {
+        if (setValueSize != sizeof(tpmData.permanent.data.rngState))
+          return TPM_BAD_PARAMETER;
+        memcpy(&tpmData.permanent.data.rngState, setValue, setValueSize);
+        return TPM_SUCCESS;
+      } else {
         return TPM_BAD_PARAMETER;
-      memcpy(&tpmData.permanent.data.rngState, setValue, setValueSize);
-      return TPM_SUCCESS;
-#endif /* TPM_ENABLE_PRNG_STATE_SETTING */
-
+      }
 
     case 23:
       if (!ownerAuth) return TPM_AUTHFAIL;
       if (deactivated) return TPM_DEACTIVATED;
       if (disabled) return TPM_DISABLED;
       if  (tpm_unmarshal_TPM_CMK_DELEGATE(&setValue, &setValueSize, &del) != 0)
         return TPM_BAD_PARAMETER;
       tpmData.permanent.data.restrictDelegate = del;
       return TPM_SUCCESS;
 
@@ skipping 115 matching lines @@
     res = tpm_verify_auth(auth1, tpmData.permanent.data.ownerAuth, TPM_KH_OWNER);
     if (res != TPM_SUCCESS) return res;
     ownerAuth = TRUE;
   }
   /* unmarshal subCap */
   if (tpm_unmarshal_UINT32(&subCap, &subCapSize, &subCapVal) != 0)
     return TPM_BAD_PARAMETER;
   /* set capability area */
   switch (capArea) {
     case TPM_SET_PERM_FLAGS:
-      debug("[TPM_SET_PERM_FLAGS]:%d", subCap);
+      debug("[TPM_SET_PERM_FLAGS]:%d", subCapVal);
       if (setValueSize != 1 || setValue[0] & 0xfe) return TPM_BAD_PARAMETER;
       return set_perm_flags(subCapVal, setValue[0], ownerAuth,
                             deactivated, disabled);
     case TPM_SET_STCLEAR_FLAGS:
-      debug("[TPM_SET_STCLEAR_FLAGS]:%d", subCap);
+      debug("[TPM_SET_STCLEAR_FLAGS]:%d", subCapVal);
       if (setValueSize != 1 || setValue[0] & 0xfe) return TPM_BAD_PARAMETER;
       return set_stclear_flags(subCapVal, setValue[0], ownerAuth,
                                deactivated, disabled);
     case TPM_SET_STANY_FLAGS:
-      debug("[TPM_SET_STANY_FLAGS]:%d", subCap);
+      debug("[TPM_SET_STANY_FLAGS]:%d", subCapVal);
       if (setValueSize != 1 || setValue[0] & 0xfe) return TPM_BAD_PARAMETER;
       return set_stany_flags(subCapVal, setValue[0], ownerAuth,
                              deactivated, disabled);
     case TPM_SET_PERM_DATA:
-      debug("[TPM_SET_PERM_DATA]:%d", subCap);
+      debug("[TPM_SET_PERM_DATA]:%d", subCapVal);
       return set_perm_data(subCapVal, setValue, setValueSize, ownerAuth,
                            deactivated, disabled);
     case TPM_SET_STCLEAR_DATA:
-      debug("[TPM_SET_STCLEAR_DATA]:%d", subCap);
+      debug("[TPM_SET_STCLEAR_DATA]:%d", subCapVal);
       return set_stclear_data(subCapVal, setValue, setValueSize, ownerAuth,
                               deactivated, disabled);
     case TPM_SET_STANY_DATA:
-      debug("[TPM_SET_STANY_DATA]:%d", subCap);
+      debug("[TPM_SET_STANY_DATA]:%d", subCapVal);
       return set_stany_data(subCapVal, setValue, setValueSize, ownerAuth,
                             deactivated, disabled);
     case TPM_SET_VENDOR:
-      debug("[TPM_SET_VENDOR]");
+      debug("[TPM_SET_VENDOR]:%d", subCapVal);
       return set_vendor(subCapVal, setValue, setValueSize, ownerAuth,
                         deactivated, disabled);
   }
   return TPM_BAD_PARAMETER;
 }
 
 TPM_RESULT TPM_GetCapabilityOwner(TPM_AUTH *auth1, TPM_VERSION *version,
                                   UINT32 *non_volatile_flags, 
                                   UINT32 *volatile_flags)
 {
@@ skipping 56 matching lines @@
     *volatile_flags |= (1 <<  1);
   if (tpmData.stclear.flags.physicalPresence)
     *volatile_flags |= (1 <<  2);
   if (tpmData.stclear.flags.physicalPresenceLock)
     *volatile_flags |= (1 <<  3);
   if (tpmData.stclear.flags.bGlobalLock)
     *volatile_flags |= (1 <<  4);
   
   return TPM_SUCCESS;
 }