Do not directly manipulate global structs. Work on the local copy instead.

utility/tlcl_generator.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.
  */
 
 /* This program generates partially filled TPM datagrams and other compile-time
  * constants (e.g. structure sizes and offsets).  Compile this file---and ONLY
  * this file---with -fpack-struct.  We take advantage of the fact that the
  * (packed) TPM structures layout (mostly) match the TPM request and response
  * datagram layout.  When they don't completely match, some fixing is necessary
  * (see PCR_SELECTION_FIX below).
  */
 
+#include <assert.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <tss/tcs.h>
 
 #include "tlcl.h"
 #include "tlcl_internal.h"
 #include "tpmextras.h"
-#include "utility.h"
 
 /* See struct Command below.  This structure represent a field in a TPM
  * command.  [name] is the field name.  [visible] is 1 if the field is
  * modified by the run-time.  Non-visible fields are initialized at build time
  * and remain constant.  [size] is the field size in bytes.  [value] is the
  * fixed value of non-visible fields.
  */
 typedef struct Field {
   const char* name;
   int visible;
@@ skipping 14 matching lines @@
   int size;
   int max_size;
   Field* fields;
   struct Command* next;
 } Command;
 
 /* Adds a field to a command, and makes its offset visible.  The fields must be
  * added at increasing offsets.
  */
 static void AddVisibleField(Command* cmd, const char* name, int offset) {
-  Field* fld = (Field*) Malloc(sizeof(Field));
+  Field* fld = (Field*) malloc(sizeof(Field));
   if (cmd->fields != NULL) {
-    Field* fn = cmd->fields;
     assert(offset > fn->offset);
   }
   fld->next = cmd->fields;
   cmd->fields = fld;
   fld->name = name;
   fld->visible = 1;
   fld->offset = offset;
 }
 
 /* Adds a constant field with its value.  The fields must be added at
  * increasing offsets.
  */
 static void AddInitializedField(Command* cmd, int offset,
                                 int size, uint32_t value) {
-  Field* fld = (Field*) Malloc(sizeof(Field));
+  Field* fld = (Field*) malloc(sizeof(Field));
   fld->next = cmd->fields;
   cmd->fields = fld;
   fld->name = NULL;
   fld->visible = 0;
   fld->size = size;
   fld->offset = offset;
   fld->value = value;
 }
 
 /* Create a structure representing a TPM command datagram.
  */
 Command* newCommand(TPM_COMMAND_CODE code, int size) {
-  Command* cmd = (Command*) Malloc(sizeof(Command));
+  Command* cmd = (Command*) malloc(sizeof(Command));
   cmd->size = size;
   AddInitializedField(cmd, 0, sizeof(TPM_TAG), TPM_TAG_RQU_COMMAND);
   AddInitializedField(cmd, sizeof(TPM_TAG), sizeof(uint32_t), size);
   AddInitializedField(cmd, sizeof(TPM_TAG) + sizeof(uint32_t),
                       sizeof(TPM_COMMAND_CODE), code);
   return cmd;
 }
 
 /* The TPM_PCR_SELECTION structure in /usr/include/tss/tpm.h contains a pointer
  * instead of an array[3] of bytes, so we need to adjust sizes and offsets
@@ skipping 201 matching lines @@
 
 /* Output the fields of a structure.
  */
 void OutputFields(Field* fld) {
   /*
    * Field order is reversed.
    */
   if (fld != NULL) {
     OutputFields(fld->next);
     if (fld->visible) {
-      printf("  uint8_t* %s;\n", fld->name);
+      printf("  uint16_t %s;\n", fld->name);
     }
   }
 }
 
 /* Outputs a structure initializer.
  */
 int OutputBytes_(Command* cmd, Field* fld) {
   int cursor = 0;
   int i;
   /*
@@ skipping 23 matching lines @@
       cursor += 2;
       break;
     case 4:
       printf("0x%x, 0x%x, 0x%x, 0x%x, ", fld->value >> 24,
              (fld->value >> 16) & 0xff,
              (fld->value >> 8) & 0xff,
              fld->value & 0xff);
       cursor += 4;
       break;
     default:
-      error("invalid field size %d\n", fld->size);
+      fprintf(stderr, "invalid field size %d\n", fld->size);
+      exit(1);
       break;
     }
   }
   return cursor;
 }
 
 /* Helper to output a structure initializer.
  */
 void OutputBytes(Command* cmd) {
   (void) OutputBytes_(cmd, cmd->fields);
 }
 
 void OutputFieldPointers(Command* cmd, Field* fld) {
   if (fld == NULL) {
     return;
   } else {
     OutputFieldPointers(cmd, fld->next);
     if (fld->visible) {
-      printf("%s.buffer + %d, ", cmd->name, fld->offset);
+      printf("%d, ", fld->offset);
     }
   }
 }
 
 /* Outputs the structure initializers for all commands.
  */
 void OutputCommands(Command* cmd) {
   if (cmd == NULL) {
     return;
   } else {
-    printf("struct {\n  uint8_t buffer[%d];\n",
-           cmd->size == 0 ? cmd->max_size : cmd->size);
+    printf("struct s_%s{\n  uint8_t buffer[%d];\n",
+           cmd->name, cmd->size == 0 ? cmd->max_size : cmd->size);
     OutputFields(cmd->fields);
     printf("} %s = {{", cmd->name);
     OutputBytes(cmd);
     printf("},\n");
     OutputFieldPointers(cmd, cmd->fields);
     printf("};\n\n");
   }
   OutputCommands(cmd->next);
 }
 
@@ skipping 12 matching lines @@
   BuildPhysicalEnableCommand,
   BuildPhysicalSetDeactivatedCommand,
   BuildGetFlagsCommand,
   BuildGetPermissionsCommand,
   BuildExtendCommand,
 };
 
 static void FreeFields(Field* fld) {
   if (fld != NULL) {
     Field* next_field = fld->next;
-    Free(fld);
+    free(fld);
     FreeFields(next_field);
   }
 }
 
 static void FreeCommands(Command* cmd) {
   if (cmd != NULL) {
     Command* next_command = cmd->next;
-    Free(cmd);
+    free(cmd);
     FreeFields(cmd->fields);
     FreeCommands(next_command);
   }
 }
 
 int main(void) {
   Command* commands = NULL;
   int i;
   for (i = 0; i < sizeof(builders) / sizeof(builders[0]); i++) {
     Command* cmd = builders[i]();
     cmd->next = commands;
     commands = cmd;
   }
 
   printf("/* This file is automatically generated */\n\n");
   OutputCommands(commands);
   printf("const int kWriteInfoLength = %d;\n", (int) sizeof(TPM_WRITE_INFO));
   printf("const int kNvDataPublicPermissionsOffset = %d;\n",
          (int) (offsetof(TPM_NV_DATA_PUBLIC, permission) +
                 2 * PCR_SELECTION_FIX +
                 offsetof(TPM_NV_ATTRIBUTES, attributes)));
 
   FreeCommands(commands);
   return 0;
 }