Handle short read error correctly in vbutil_kernel.c

utility/vbutil_kernel.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.
  *
  * Verified boot kernel utility
  */
 
 #include <errno.h>
 #include <getopt.h>
 #include <inttypes.h>  /* For PRIu64 */
@@ skipping 110 matching lines @@
   if (!opt_debug)
     return;
 
   va_list ap;
   va_start(ap, format);
   fprintf(stderr, "DEBUG: ");
   vfprintf(stderr, format, ap);
   va_end(ap);
 }
 
+/* Return an explanation when fread() fails. */
+static const char *error_fread(FILE *fp) {
+  const char *retval = "beats me why";
+  if (feof(fp))
+    retval = "EOF";
+  else if (ferror(fp))
+    retval = strerror(errno);
+  clearerr(fp);
+  return retval;
+}
 
 /* Return the smallest integral multiple of [alignment] that is equal
  * to or greater than [val]. Used to determine the number of
  * pages/sectors/blocks/whatever needed to contain [val]
  * items/bytes/etc. */
 static uint64_t roundup(uint64_t val, uint64_t alignment) {
   uint64_t rem = val % alignment;
   if ( rem )
     return val + (alignment - rem);
   return val;
@@ skipping 237 matching lines @@
   uint64_t now = 0;
   uint8_t* buf = NULL;
   int ret_error = 1;
 
   if (!filename) {
     error("Must specify prepacked blob to read\n");
     return 0;
   }
 
   if (0 != stat(filename, &statbuf)) {
-    error("unable to stat %s: %s\n", filename, strerror(errno));
+    error("Unable to stat %s: %s\n", filename, strerror(errno));
     return 0;
   }
 
   Debug("%s size is 0x%" PRIx64 "\n", filename, statbuf.st_size);
   if (statbuf.st_size < DEFAULT_PADDING) {
     error("%s is too small to be a valid kernel blob\n");
     return 0;
   }
 
   Debug("Reading %s\n", filename);
   fp = fopen(filename, "rb");
   if (!fp) {
     error("Unable to open file %s: %s\n", filename, strerror(errno));
     return 0;
   }
 
   buf = Malloc(DEFAULT_PADDING);
   if (!buf) {
     error("Unable to allocate padding\n");
     goto unwind_oldblob;
   }
 
   if (1 != fread(buf, DEFAULT_PADDING, 1, fp)) {
-    error("Unable to read header from %s: %s\n", filename, strerror(errno));
+    error("Unable to read header from %s: %s\n", filename, error_fread(fp));
     goto unwind_oldblob;
   }
 
   /* Skip the key block */
   key_block = (VbKeyBlockHeader*)buf;
   Debug("Keyblock is 0x%" PRIx64 " bytes\n", key_block->key_block_size);
   now += key_block->key_block_size;
   if (now > statbuf.st_size) {
     error("key_block_size advances past the end of the blob\n");
     goto unwind_oldblob;
@@ skipping 30 matching lines @@
   bp->kernel_version = preamble->kernel_version;
   bp->bootloader_address = preamble->bootloader_address;
   bp->bootloader_size = preamble->bootloader_size;
   bp->blob_size = preamble->body_signature.data_size;
 
   Debug(" kernel_version = %d\n", bp->kernel_version);
   Debug(" bootloader_address = 0x%" PRIx64 "\n", bp->bootloader_address);
   Debug(" bootloader_size = 0x%" PRIx64 "\n", bp->bootloader_size);
   Debug(" blob_size = 0x%" PRIx64 "\n", bp->blob_size);
 
+  if (!bp->blob_size) {
+    error("No kernel blob found\n");
+    goto unwind_oldblob;
+  }
+
   bp->blob = (uint8_t *)Malloc(bp->blob_size);
   if (!bp->blob) {
     error("Couldn't allocate 0x%" PRIx64 " bytes for blob_t.\n", bp->blob_size);
     goto unwind_oldblob;
   }
 
   /* read it in */
   if (1 != fread(bp->blob, bp->blob_size, 1, fp)) {
-    error("Unable to read kernel blob from %s: %s\n", filename, strerror(errno));
+    error("Unable to read kernel blob from %s: %s\n", filename, error_fread(fp));
     goto unwind_oldblob;
   }
 
   ret_error = 0;
 
   /* done */
 unwind_oldblob:
   fclose(fp);
   if (ret_error) {
     if (bp) {
@@ skipping 387 matching lines @@
 
     case OPT_MODE_VERIFY:
       return Verify(filename, signpubkey, verbose);
 
     default:
       fprintf(stderr,
               "You must specify a mode: --pack, --repack or --verify\n");
       return PrintHelp(progname);
   }
 }