Clean up some style violations.

utility/dev_sign_file.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.
  *
  * Developer file-signing utility
  */
 
 #include <errno.h>
 #include <getopt.h>
 #include <inttypes.h>  /* For PRIu64 */
@@ skipping 29 matching lines @@
   {"verify", 1, 0,                    OPT_MODE_VERIFY             },
   {"keyblock", 1, 0,                  OPT_KEYBLOCK                },
   {"signprivate", 1, 0,               OPT_SIGNPRIVATE             },
   {"vblock", 1, 0,                    OPT_VBLOCK                  },
   {"debug", 0, &opt_debug, 1                                      },
   {NULL, 0, 0, 0}
 };
 
 
 /* Print help and return error */
-static int PrintHelp(char *progname) {
+static int PrintHelp(const char *progname) {
   fprintf(stderr,
           "This program is used to sign and verify developer-mode files\n");
   fprintf(stderr,
           "\n"
           "Usage:  %s --sign <file> [PARAMETERS]\n"
           "\n"
           "  Required parameters:\n"
           "    --keyblock <file>         Key block in .keyblock format\n"
           "    --signprivate <file>"
           "      Private key to sign file data, in .vbprivk format\n"
@@ skipping 20 matching lines @@
   fprintf(stderr, "DEBUG: ");
   vfprintf(stderr, format, ap);
   va_end(ap);
 }
 
 
 /* Sign a file. We'll reuse the same structs used to sign kernels, to avoid
    having to declare yet another one for just this purpose. */
 static int Sign(const char* filename, const char* keyblock_file,
                 const char* signprivate_file, const char* outfile) {
-  uint8_t *file_data;
+  uint8_t* file_data;
   uint64_t file_size;
   VbKeyBlockHeader* key_block;
   uint64_t key_block_size;
   VbPrivateKey* signing_key;
   VbSignature* body_sig;
   VbKernelPreambleHeader* preamble;
-  FILE* f;
-  uint64_t i;
+  FILE* output_fp;
 
   /* Read the file that we're going to sign. */
   file_data = ReadFile(filename, &file_size);
   if (!file_data) {
     error("Error reading file to sign.\n");
     return 1;
   }
 
   /* Get the key block and read the private key corresponding to it. */
   key_block = (VbKeyBlockHeader*)ReadFile(keyblock_file, &key_block_size);
   if (!key_block) {
     error("Error reading key block.\n");
     return 1;
   }
   signing_key = PrivateKeyRead(signprivate_file);
   if (!signing_key) {
     error("Error reading signing key.\n");
     return 1;
   }
 
   /* Sign the file data */
   body_sig = CalculateSignature(file_data, file_size, signing_key);
   if (!body_sig) {
     error("Error calculating body signature\n");
     return 1;
   }
 
   /* Create preamble */
-  preamble = CreateKernelPreamble(0UL, 0UL, 0UL, 0UL,
-                                  body_sig, 0UL, signing_key);
+  preamble = CreateKernelPreamble((uint64_t)0,
+                                  (uint64_t)0,
+                                  (uint64_t)0,
+                                  (uint64_t)0,
+                                  body_sig,
+                                  (uint64_t)0,
+                                  signing_key);
   if (!preamble) {
     error("Error creating preamble.\n");
     return 1;
   }
 
   /* Write the output file */
   Debug("writing %s...\n", outfile);
-  f = fopen(outfile, "wb");
-  if (!f) {
+  output_fp = fopen(outfile, "wb");
+  if (!output_fp) {
     error("Can't open output file %s\n", outfile);
     return 1;
   }
   Debug("0x%" PRIx64 " bytes of key_block\n", key_block_size);
   Debug("0x%" PRIx64 " bytes of preamble\n", preamble->preamble_size);
-  i = ((1 != fwrite(key_block, key_block_size, 1, f)) ||
-       (1 != fwrite(preamble, preamble->preamble_size, 1, f)));
-  if (i) {
+  if ((1 != fwrite(key_block, key_block_size, 1, output_fp)) ||
+      (1 != fwrite(preamble, preamble->preamble_size, 1, output_fp))) {
     error("Can't write output file %s\n", outfile);
-    fclose(f);
+    fclose(output_fp);
     unlink(outfile);
     return 1;
   }
-  fclose(f);
+  fclose(output_fp);
 
   /* Done */
   Free(preamble);
   Free(body_sig);
   Free(signing_key);
   Free(key_block);
   Free(file_data);
 
   /* Success */
   return 0;
 }
 
 static int Verify(const char* filename, const char* vblock_file) {
-  uint8_t *file_data;
+  uint8_t* file_data;
   uint64_t file_size;
-  uint8_t *buf;
+  uint8_t* buf;
   uint64_t buf_size;
   VbKeyBlockHeader* key_block;
   VbKernelPreambleHeader* preamble;
   VbPublicKey* data_key;
   RSAPublicKey* rsa;
-  uint64_t now = 0;
+  uint64_t current_buf_offset = 0;
 
   /* Read the file that we're going to verify. */
   file_data = ReadFile(filename, &file_size);
   if (!file_data) {
     error("Error reading file to sign.\n");
     return 1;
   }
 
   /* Read the vblock that we're going to use on it */
   buf = ReadFile(vblock_file, &buf_size);
   if (!buf) {
     error("Error reading vblock_file.\n");
     return 1;
   }
 
   /* Find 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 > buf_size) {
+  current_buf_offset += key_block->key_block_size;
+  if (current_buf_offset > buf_size) {
     error("key_block_size advances past the end of the buffer\n");
     return 1;
   }
 
   /* Find the preamble */
-  preamble = (VbKernelPreambleHeader*)(buf + now);
+  preamble = (VbKernelPreambleHeader*)(buf + current_buf_offset);
   Debug("Preamble is 0x%" PRIx64 " bytes\n", preamble->preamble_size);
-  now += preamble->preamble_size;
-  if (now > buf_size ) {
+  current_buf_offset += preamble->preamble_size;
+  if (current_buf_offset > buf_size ) {
     error("preamble_size advances past the end of the buffer\n");
     return 1;
   }
 
-  Debug("Now is at 0x%" PRIx64 " bytes\n", now);
+  Debug("Current buf offset is at 0x%" PRIx64 " bytes\n", current_buf_offset);
 
   /* Check the keyblock */
   if (0 != KeyBlockVerify(key_block, file_size, NULL)) {
     error("Error verifying key block.\n");
     return 1;
   }
 
   printf("Key block:\n");
   data_key = &key_block->data_key;
-//HEY   printf("  Signature:           %s\n", sign_key ? "valid" : "ignored");
   printf("  Size:                0x%" PRIx64 "\n", key_block->key_block_size);
   printf("  Data key algorithm:  %" PRIu64 " %s\n", data_key->algorithm,
          (data_key->algorithm < kNumAlgorithms ?
           algo_strings[data_key->algorithm] : "(invalid)"));
   printf("  Data key version:    %" PRIu64 "\n", data_key->key_version);
   printf("  Flags:               %" PRIu64 "\n", key_block->key_block_flags);
 
 
   /* Verify preamble */
   rsa = PublicKeyToRSA(&key_block->data_key);
   if (!rsa) {
     error("Error parsing data key.\n");
     return 1;
   }
-  if (0 != VerifyKernelPreamble(
-        preamble, file_size, rsa)) {
+  if (0 != VerifyKernelPreamble(preamble, file_size, rsa)) {
     error("Error verifying preamble.\n");
     return 1;
   }
 
   printf("Preamble:\n");
   printf("  Size:                0x%" PRIx64 "\n", preamble->preamble_size);
   printf("  Header version:      %" PRIu32 ".%" PRIu32"\n",
          preamble->header_version_major, preamble->header_version_minor);
   printf("  Kernel version:      %" PRIu64 "\n", preamble->kernel_version);
   printf("  Body load address:   0x%" PRIx64 "\n", preamble->body_load_address);
   printf("  Body size:           0x%" PRIx64 "\n",
          preamble->body_signature.data_size);
   printf("  Bootloader address:  0x%" PRIx64 "\n",
          preamble->bootloader_address);
   printf("  Bootloader size:     0x%" PRIx64 "\n", preamble->bootloader_size);
 
   /* Verify body */
-  if (0 != VerifyData(file_data, file_size, &preamble->body_signature,
-                      rsa)) {
+  if (0 != VerifyData(file_data, file_size, &preamble->body_signature, rsa)) {
     error("Error verifying kernel body.\n");
     return 1;
   }
   printf("Body verification succeeded.\n");
 
-  // HEY
   return 0;
 }
 
 
 int main(int argc, char* argv[]) {
   char* filename = NULL;
   char* keyblock_file = NULL;
   char* signprivate_file = NULL;
   char* vblock_file = NULL;
   int mode = 0;
   int parse_error = 0;
-  int i;
+  int option_index;
 
   char *progname = strrchr(argv[0], '/');
   if (progname)
     progname++;
   else
     progname = argv[0];
 
-  while (((i = getopt_long(argc, argv, ":", long_opts, NULL)) != -1) &&
+  while ((option_index = getopt_long(argc, argv, ":", long_opts, NULL)) != -1 &&
          !parse_error) {
-    switch (i) {
+    switch (option_index) {
       default:
       case '?':
         /* Unhandled option */
         parse_error = 1;
         break;
 
       case 0:
         /* silently handled option */
         break;
 
       case OPT_MODE_SIGN:
       case OPT_MODE_VERIFY:
-        if (mode && (mode != i)) {
+        if (mode && (mode != option_index)) {
           fprintf(stderr, "Only a single mode can be specified\n");
           parse_error = 1;
           break;
         }
-        mode = i;
+        mode = option_index;
         filename = optarg;
         break;
 
       case OPT_KEYBLOCK:
         keyblock_file = optarg;
         break;
 
       case OPT_SIGNPRIVATE:
         signprivate_file = optarg;
         break;
@@ skipping 21 matching lines @@
         return PrintHelp(progname);
       }
       return Verify(filename, vblock_file);
 
     default:
       fprintf(stderr,
               "You must specify either --sign or --verify\n");
       return PrintHelp(progname);
   }
 
-  return 1;
+  /* NOTREACHED */

[adlr, 2010/08/11 19:14:26]

btw, i'm fine w/ having a return 1 here, which may be nice if gcc gives a
spurious warning. I was just thinking a comment may be nice to point out to
future humans that this code isn't executed.

 }