Make all TPM command functions return TPM_SUCCESS or the TPM error code.

src/tlcl/tlcl.c

 /* Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /* A lightweight TPM command library.
  *
  * The general idea is that TPM commands are array of bytes whose fields are
  * mostly compile-time constant.  The goal is to build much of the commands at
  * compile time (or build time) and change some of the fields at run time as
@@ skipping 185 matching lines @@
      response_tag == TPM_TAG_RSP_COMMAND) ||
     (tag == TPM_TAG_RQU_AUTH1_COMMAND &&
      response_tag == TPM_TAG_RSP_AUTH1_COMMAND) ||
     (tag == TPM_TAG_RQU_AUTH2_COMMAND &&
      response_tag == TPM_TAG_RSP_AUTH2_COMMAND));
   assert(response_length == TpmCommandSize(response));
 #endif  /* FIRMWARE */
 
 }
 
-/* Sends a command and checks the result for errors.  Note that this error
- * checking is only meaningful when running in user mode.  TODO: The entire
- * error recovery strategy in the firmware needs more work.
+/* Sends a command and returns the error code.
  */
-static void Send(uint8_t* command) {
+static uint32_t Send(uint8_t* command) {
   uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
   SendReceive(command, response, sizeof(response));
-  CheckResult(command, response, false);
+  return TpmReturnCode(response);
 }
 
-
 /* Exported functions.
  */
 
 void TlclLog(char* format, ...) {
   va_list ap;
   if (tlcl_log_level > 0) {
     va_start(ap, format);
     vprintf(format, ap);
     va_end(ap);
   }
 }
 
 void TlclSetLogLevel(int level) {
   tlcl_log_level = level;
 }
 
 void TlclLibInit(void) {
 #if USE_TPM_EMULATOR
   tpmemu_init();
 #else
 #if !FIRMWARE
   tpm_fd = open("/dev/tpm0", O_RDWR);
   if (tpm_fd < 0) {
     error("cannot open TPM device: %s\n", strerror(errno));
   }
 #endif  /* !FIRMWARE */
 #endif  /* USE_TPM_EMULATOR */
 }
 
-void TlclStartup(void) {
-  Send(tpm_startup_cmd.buffer);
+uint32_t TlclStartup(void) {
+  return Send(tpm_startup_cmd.buffer);
 }
 
-void TlclSelftestfull(void) {
-  Send(tpm_selftestfull_cmd.buffer);
+uint32_t TlclSelftestfull(void) {
+  return Send(tpm_selftestfull_cmd.buffer);
 }
 
-void TlclDefineSpace(uint32_t index, uint32_t perm, uint32_t size) {
+uint32_t TlclDefineSpace(uint32_t index, uint32_t perm, uint32_t size) {
   ToTpmUint32(tpm_nv_definespace_cmd.index, index);
   ToTpmUint32(tpm_nv_definespace_cmd.perm, perm);
   ToTpmUint32(tpm_nv_definespace_cmd.size, size);
-  Send(tpm_nv_definespace_cmd.buffer);
+  return Send(tpm_nv_definespace_cmd.buffer);
 }
 
 uint32_t TlclWrite(uint32_t index, uint8_t* data, uint32_t length) {
   uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
   const int total_length =
     kTpmRequestHeaderLength + kWriteInfoLength + length;
 
   assert(total_length <= TPM_LARGE_ENOUGH_COMMAND_SIZE);
   SetTpmCommandSize(tpm_nv_write_cmd.buffer, total_length);
 
@@ skipping 20 matching lines @@
   if (result == TPM_SUCCESS && length > 0) {
     uint8_t* nv_read_cursor = response + kTpmResponseHeaderLength;
     FromTpmUint32(nv_read_cursor, &result_length);
     nv_read_cursor += sizeof(uint32_t);
     memcpy(data, nv_read_cursor, result_length);
   }
 
   return result;
 }
 
-void TlclWriteLock(uint32_t index) {
-  if (TlclWrite(index, NULL, 0) != TPM_SUCCESS) {
-    error("failed to write lock space 0x%x\n", index);
-  }
+uint32_t TlclWriteLock(uint32_t index) {
+  return TlclWrite(index, NULL, 0);
 }
 
-void TlclReadLock(uint32_t index) {
-  if (TlclRead(index, NULL, 0) != TPM_SUCCESS) {
-    error("failed to read lock space 0x%x\n", index);
-  }
+uint32_t TlclReadLock(uint32_t index) {
+  return TlclRead(index, NULL, 0);
 }
 
-void TlclAssertPhysicalPresence(void) {
-  Send(tpm_ppassert_cmd.buffer);
+uint32_t TlclAssertPhysicalPresence(void) {
+  return Send(tpm_ppassert_cmd.buffer);
 }
 
 uint32_t TlclLockPhysicalPresence(void) {
-  uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
-  SendReceive(tpm_pplock_cmd.buffer, response, sizeof(response));
-  return TpmReturnCode(response);
+  return Send(tpm_pplock_cmd.buffer);
 }
 
-void TlclSetNvLocked(void) {
-  TlclDefineSpace(TPM_NV_INDEX_LOCK, 0, 0);
+uint32_t TlclSetNvLocked(void) {
+  return TlclDefineSpace(TPM_NV_INDEX_LOCK, 0, 0);
 }
 
 int TlclIsOwned(void) {
   uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE + TPM_PUBEK_SIZE];
   uint32_t result;
   SendReceive(tpm_readpubek_cmd.buffer, response, sizeof(response));
   result = TpmReturnCode(response);
   return (result != TPM_SUCCESS);
 }
 
-void TlclForceClear(void) {
-  uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
-  uint32_t result;
-  SendReceive(tpm_forceclear_cmd.buffer, response, sizeof(response));
-  result = TpmReturnCode(response);
-  if (result != TPM_SUCCESS) {
-    warning("ForceClear failed with code %d (0x%x)\n", result, result);
-  }
+uint32_t TlclForceClear(void) {
+  return Send(tpm_forceclear_cmd.buffer);
 }
 
-void TlclSetEnable(void) {
-  Send(tpm_physicalenable_cmd.buffer);
+uint32_t TlclSetEnable(void) {
+  return Send(tpm_physicalenable_cmd.buffer);
 }
 
-int TlclSetDeactivated(uint8_t flag) {
-  uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
-  uint32_t result;
+uint32_t TlclSetDeactivated(uint8_t flag) {
   *((uint8_t*)tpm_physicalsetdeactivated_cmd.deactivated) = flag;
-  SendReceive(tpm_physicalsetdeactivated_cmd.buffer,
-              response, sizeof(response));
-  result = TpmReturnCode(response);
-  return result;
+  return Send(tpm_physicalsetdeactivated_cmd.buffer);
 }
 
-int TlclGetFlags(uint8_t* disable, uint8_t* deactivated) {
+uint32_t TlclGetFlags(uint8_t* disable, uint8_t* deactivated) {
   uint8_t response[TPM_LARGE_ENOUGH_COMMAND_SIZE];
   TPM_PERMANENT_FLAGS* pflags;
   uint32_t result;
   uint32_t size;
 
   SendReceive(tpm_getcapability_cmd.buffer, response, sizeof(response));
   result = TpmReturnCode(response);
   if (result != TPM_SUCCESS) {
     return result;
   }
   FromTpmUint32(response + kTpmResponseHeaderLength, &size);
   assert(size == sizeof(TPM_PERMANENT_FLAGS));
   pflags =
     (TPM_PERMANENT_FLAGS*) (response + kTpmResponseHeaderLength + sizeof(size));
   *disable = pflags->disable;
   *deactivated = pflags->deactivated;
   return result;
 }
 
 uint32_t TlclSetGlobalLock(void) {
   uint32_t x;
   return TlclWrite(TPM_NV_INDEX0, (uint8_t*) &x, 0);
 }