Vboot Reference: Make length types explicitly sized.

src/platform/vboot_reference/utils/firmware_image.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.
  *
  * Functions for generating and manipulating a verified boot firmware image.
  */
 
 #include "firmware_image.h"
 
 #include <fcntl.h>
@@ skipping 29 matching lines @@
   if (image) {
     Free(image->firmware_sign_key);
     Free(image->preamble_signature);
     Free(image->firmware_signature);
     Free(image->firmware_data);
     Free(image);
   }
 }
 
 FirmwareImage* ReadFirmwareImage(const char* input_file) {
-  uint32_t file_size;
+  uint64_t file_size;
   int image_len = 0;  /* Total size of the firmware image. */
   int header_len = 0;
   int firmware_sign_key_len;
   int signature_len;

[Chris Masone, 2010/03/11 02:30:46]

what about the above?  Are they all ok to be < 64 bits?

[gauravsh, 2010/03/11 02:33:39]

Yes, these are always going to be bounded. 

   uint8_t* firmware_buf;
   MemcpyState st;
   FirmwareImage* image = FirmwareImageNew();
 
   if (!image)
     return NULL;
 
   firmware_buf = BufferFromFile(input_file, &file_size);
   image_len = file_size;
 
@@ skipping 116 matching lines @@
   StatefulMemcpy_r(&st, image->preamble, FIELD_LEN(preamble));
 
   if (st.remaining_len != 0 ) {  /* Underrun or Overrun. */
     Free(preamble_blob);
     return NULL;
   }
   return preamble_blob;
 }
 
 
-uint8_t* GetFirmwareBlob(const FirmwareImage* image, int* blob_len) {
+uint8_t* GetFirmwareBlob(const FirmwareImage* image, uint64_t* blob_len) {
   int firmware_signature_len;
   uint8_t* firmware_blob = NULL;
   uint8_t* header_blob = NULL;
   uint8_t* preamble_blob = NULL;
   MemcpyState st;
 
   if (!image)
     return NULL;
 
   firmware_signature_len = siglen_map[image->firmware_sign_algorithm];
@@ skipping 26 matching lines @@
     Free(firmware_blob);
     return NULL;
   }
   return firmware_blob;
 }
 
 int WriteFirmwareImage(const char* input_file,
                        const FirmwareImage* image) {
   int fd;
   uint8_t* firmware_blob;
-  int blob_len;
+  uint64_t blob_len;
 
   if (!image)
     return 0;
   if (-1 == (fd = creat(input_file, S_IRWXU))) {
     fprintf(stderr, "Couldn't open file for writing.\n");
     return 0;
   }
 
   firmware_blob = GetFirmwareBlob(image, &blob_len);
   if (!firmware_blob) {
@@ skipping 20 matching lines @@
          "Algorithm Id = %d\n"
          "Signature Algorithm = %s\n"
          "Key Version = %d\n\n",
          image->header_len,
          image->firmware_sign_algorithm,
          algo_strings[image->firmware_sign_algorithm],
          image->firmware_key_version);
   /* TODO(gauravsh): Output hash and key signature here? */
   /* Print preamble. */
   printf("Firmware Version = %d\n"
-         "Firmware Length = %d\n\n",
+         "Firmware Length = %" PRIu64 "\n\n",
          image->firmware_version,
          image->firmware_len);
   /* Output key signature here? */
 }
 
 char* kVerifyFirmwareErrors[VERIFY_FIRMWARE_MAX] = {
   "Success.",
   "Invalid Image.",
   "Root Key Signature Failed.",
   "Invalid Verification Algorithm.",
@@ skipping 289 matching lines @@
   if (!(firmware_signature = SignatureBuf(image->firmware_data,
                                           image->firmware_len,
                                           signing_key_file,
                                           image->firmware_sign_algorithm)))
     return 0;
   image->firmware_signature = (uint8_t*) Malloc(signature_len);
   Memcpy(image->firmware_signature, firmware_signature, signature_len);
   Free(firmware_signature);
   return 1;
 }