random cleanup

src/platform/vboot_reference/vkernel/kernel_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 kernel image.
  * (Userland portion)
  */
 #include "kernel_image.h"
 
 #include <fcntl.h>
@@ skipping 315 matching lines @@
                      int is_subkey_out) {
   int fd;
   int success = 1;
   uint8_t* kernel_blob = NULL;
   uint8_t* subkey_out_buf = NULL;
   uint8_t* subkey_header = NULL;
   uint64_t blob_len;
 
   if (!image)
     return 0;
-  if (-1 == (fd = creat(output_file, S_IRWXU))) {
+  if (-1 == (fd = creat(output_file, 0666))) {
     debug("Couldn't open file for writing kernel image: %s\n",
             output_file);
     return 0;
   }
   if (is_subkey_out) {
     blob_len = GetKernelHeaderLen(image) +
         siglen_map[image->firmware_sign_algorithm];
     subkey_out_buf = (uint8_t*) Malloc(blob_len);
     subkey_header = GetKernelHeaderBlob(image);
     Memcpy(subkey_out_buf, subkey_header, GetKernelHeaderLen(image));
@@ skipping 315 matching lines @@
   uint64_t i;
 
   // Read the input files.
   kernel_buf = BufferFromFile(kernel_file, &kernel_size);
   if (!kernel_buf)
     goto done0;
 
   config_buf = BufferFromFile(config_file, &config_size);
   if (!config_buf)
     goto done1;
-  if (config_size < CROS_CONFIG_SIZE) // need room for trailing '\0'
+  if (config_size >= CROS_CONFIG_SIZE) { // need room for trailing '\0'
+    error("config file %s is too large (>= %d bytes)\n",
+          config_file, CROS_CONFIG_SIZE);
     goto done1;
+  }
 
   // Replace any newlines with spaces in the config file.
   for (i=0; i < config_size; i++)
     if (config_buf[i] == '\n')
       config_buf[i] = ' ';
 
   bootloader_buf = BufferFromFile(bootloader_file, &bootloader_size);
   if (!bootloader_buf)
     goto done2;
 
   // The first part of vmlinuz is a header, followed by a real-mode boot stub.
   // We only want the 32-bit part.
   if (kernel_size) {
     lh = (struct linux_kernel_header *)kernel_buf;
     kernel32_start = (lh->setup_sects+1) << 9;
     kernel32_size = kernel_size - kernel32_start;
   }
 
   // Allocate and zero the blob we need.
   blob_size = roundup(kernel32_size, CROS_ALIGN) +
     CROS_CONFIG_SIZE +
     CROS_PARAMS_SIZE +
     roundup(bootloader_size, CROS_ALIGN);
   blob = (uint8_t *)Malloc(blob_size);
-  if (!blob)
+  if (!blob) {
+    error("Couldn't allocate %ld bytes.\n", blob_size);
     goto done3;
+  }
   Memset(blob, 0, blob_size);
   now = 0;
     
   // Copy the 32-bit kernel.
   if (kernel32_size)
     Memcpy(blob + now, kernel_buf + kernel32_start, kernel32_size);
   now += roundup(now + kernel32_size, CROS_ALIGN);
   
   // Find the load address of the commandline. We'll need it later.
   cmdline_addr = CROS_32BIT_ENTRY_ADDR + now
@@ skipping 36 matching lines @@
   // Clean up and return the blob.
 done3:
   Free(bootloader_buf);
 done2:
   Free(config_buf);
 done1:
   Free(kernel_buf);
 done0:
   return blob;
 }