Upgrade to tpm-emulator version 0.7.

tpm/tpm_marshalling.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,
- *               2005, 2006 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_marshalling.c 372 2010-02-15 12:52:00Z mast $
  */
 
 #include "tpm_marshalling.h"
 #include "tpm_handles.h"
 #include "crypto/rsa.h"
 
 int tpm_marshal_UINT32_ARRAY(BYTE **ptr, UINT32 *length,
                              UINT32 *v, UINT32 n)
 {
   UINT32 i;
@@ skipping 1658 matching lines @@
   for (i = 0; i < TPM_MAX_KEYS; i++) {
     if (tpm_unmarshal_TPM_KEY_DATA(ptr, length, &v->keys[i])) return -1;
   }
   if (tpm_unmarshal_UINT32_ARRAY(ptr, length, v->tis_timeouts, TPM_NUM_TIS_TIMEOUTS)
       || tpm_unmarshal_UINT32_ARRAY(ptr, length, v->cmd_durations, TPM_NUM_CMD_DURATIONS)) return -1;
   return 0;
 }
 
 int tpm_marshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v)
 {
-  UINT32 i;
   if (tpm_marshal_TPM_STRUCTURE_TAG(ptr, length, v->tag)
       || tpm_marshal_TPM_NONCE(ptr, length, &v->contextNonceKey)
       || tpm_marshal_TPM_COUNT_ID(ptr, length, v->countID)
       || tpm_marshal_UINT32(ptr, length, v->ownerReference)
       || tpm_marshal_BOOL(ptr, length, v->disableResetLock)
       || tpm_marshal_UINT32(ptr, length, v->deferredPhysicalPresence)) return -1;
   return 0;
 }
 
 int tpm_unmarshal_TPM_STCLEAR_DATA(BYTE **ptr, UINT32 *length, TPM_STCLEAR_DATA *v)
 {
-  UINT32 i;
   if (tpm_unmarshal_TPM_STRUCTURE_TAG(ptr, length, &v->tag)
       || tpm_unmarshal_TPM_NONCE(ptr, length, &v->contextNonceKey)
       || tpm_unmarshal_TPM_COUNT_ID(ptr, length, &v->countID)
       || tpm_unmarshal_UINT32(ptr, length, &v->ownerReference)
       || tpm_unmarshal_BOOL(ptr, length, &v->disableResetLock)
       || tpm_unmarshal_UINT32(ptr, length, &v->deferredPhysicalPresence)) return -1;
   return 0;
 }
 
 int tpm_marshal_TPM_SESSION_DATA(BYTE **ptr, UINT32 *length, TPM_SESSION_DATA *v)
@@ skipping 63 matching lines @@
     if (tpm_unmarshal_TPM_SESSION_DATA(ptr, length, &v->sessions[i])) return -1;
   }
   for (i = 0; i < TPM_MAX_SESSIONS_DAA; i++) {
     if (tpm_unmarshal_TPM_DAA_SESSION_DATA(ptr, length, &v->sessionsDAA[i])) return -1;
   }
   if (tpm_unmarshal_DAAHANDLE(ptr, length, &v->currentDAA)
       || tpm_unmarshal_TPM_TRANSHANDLE(ptr, length, &v->transExclusive)) return -1;
   return 0;
 }
 
+int tpm_marshal_TPM_DATA(BYTE **ptr, UINT32 *length, TPM_DATA *v)
+{
+  if (tpm_marshal_TPM_PERMANENT_FLAGS(ptr, length, &v->permanent.flags)
+      || tpm_marshal_BOOL(ptr, length, v->permanent.flags.selfTestSucceeded)
+      || tpm_marshal_BOOL(ptr, length, v->permanent.flags.owned)
+      || tpm_marshal_TPM_PERMANENT_DATA(ptr, length, &v->permanent.data)
+      || tpm_marshal_TPM_STCLEAR_FLAGS(ptr, length, &v->stclear.flags)
+      || tpm_marshal_TPM_STCLEAR_DATA(ptr, length, &v->stclear.data)
+      || tpm_marshal_TPM_STANY_DATA(ptr, length, &v->stany.data)) return -1;
+  return 0;
+}
+
+int tpm_unmarshal_TPM_DATA(BYTE **ptr, UINT32 *length, TPM_DATA *v)
+{
+  if (tpm_unmarshal_TPM_PERMANENT_FLAGS(ptr, length, &v->permanent.flags)
+      || tpm_unmarshal_BOOL(ptr, length, &v->permanent.flags.selfTestSucceeded)
+      || tpm_unmarshal_BOOL(ptr, length, &v->permanent.flags.owned)
+      || tpm_unmarshal_TPM_PERMANENT_DATA(ptr, length, &v->permanent.data)
+      || tpm_unmarshal_TPM_STCLEAR_FLAGS(ptr, length, &v->stclear.flags)
+      || tpm_unmarshal_TPM_STCLEAR_DATA(ptr, length, &v->stclear.data)
+      || tpm_unmarshal_TPM_STANY_DATA(ptr, length, &v->stany.data)) return -1;
+  return 0;
+}
+
 int tpm_marshal_TPM_RESPONSE(BYTE **ptr, UINT32 *length, TPM_RESPONSE *v)
 {
   if (tpm_marshal_TPM_TAG(ptr, length, v->tag)
       || tpm_marshal_UINT32(ptr, length, v->size)
       || tpm_marshal_TPM_RESULT(ptr, length, v->result)
       || tpm_marshal_BLOB(ptr, length, v->param, v->paramSize)) return -1;
   if (v->tag == TPM_TAG_RSP_AUTH2_COMMAND) {
     if (tpm_marshal_TPM_AUTH(ptr, length, v->auth1)
         || tpm_marshal_TPM_AUTH(ptr, length, v->auth2)) return -1;
   } else if (v->tag == TPM_TAG_RSP_AUTH1_COMMAND) {
@@ skipping 23 matching lines @@
     if (tpm_unmarshal_BLOB(ptr, length, &v->param, v->paramSize)
         || tpm_unmarshal_TPM_AUTH(ptr, length, &v->auth1)) return -1;
     v->auth1.ordinal = v->ordinal;
     v->auth2.authHandle = TPM_INVALID_HANDLE;
   } else {
     v->auth1.authHandle = TPM_INVALID_HANDLE;
     v->auth2.authHandle = TPM_INVALID_HANDLE;
   }
   return 0;
 }