vboot_reference: add creation of GBB blob to gbb_utility

utility/gbb_utility.cc

 // 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.
 //
 // Utility for manipulating Google Binary Block (GBB)
 //
 
 #include "gbb_utility.h"
 
 #include <assert.h>
 #include <getopt.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 #include <string>
 #include <vector>
 #include <algorithm>
 
 using std::string;
 
 ///////////////////////////////////////////////////////////////////////
 // Simple File Utilities
@@ skipping 344 matching lines @@
 // command line utilities
 
 #include <map>
 
 using vboot_reference::GoogleBinaryBlockUtil;
 
 // utility function: provide usage of this utility and exit.
 static void usagehelp_exit(const char *prog_name) {
   printf(
     "Utility to manage Google Binary Block (GBB)\n"
-    "Usage: %s [-g|-s] [OPTIONS] bios_file [output_file]\n"
+    "Usage: %s [-g|-s|-c] [OPTIONS] bios_file [output_file]\n"
     "\n"
     "GET MODE:\n"
     "-g, --get   (default)\tGet (read) from bios_file, "
                             "with following options:\n"
     "     --hwid          \tReport hardware id (default).\n"
     " -k, --rootkey=FILE  \tFile name to export Root Key.\n"
     " -b, --bmpfv=FILE    \tFile name to export Bitmap FV.\n"
     "     --recoverykey=FILE\tFile name to export Recovery Key.\n"
     "\n"
     "SET MODE:\n"
     "-s, --set            \tSet (write) to bios_file, "
                             "with following options:\n"
     " -o, --output=FILE   \tNew file name for ouptput.\n"
     " -i, --hwid=HWID     \tThe new hardware id to be changed.\n"
     " -k, --rootkey=FILE  \tFile name of new Root Key.\n"
     " -b, --bmpfv=FILE    \tFile name of new Bitmap FV.\n"
     "     --recoverykey=FILE\tFile name of new Recovery Key.\n"
     "\n"
+    "CREATE MODE:\n"
+    "-c, --create=prop1_size,prop2_size...\n"
+    "                     \tCreate a GBB blob by given size list.\n"
     "SAMPLE:\n"
     "  %s -g bios.bin\n"
     "  %s --set --hwid='New Model' -k key.bin bios.bin newbios.bin\n"
-    , prog_name, prog_name, prog_name);
+    "  %s -c 0x100,0x1000,0x03DE80,0x1000 gbb.blob\n"
+    , prog_name, prog_name, prog_name, prog_name);
   exit(1);
 }
 
 // utility function: export a property from GBB to given file.
 // if filename was empty, export to console (screen).
 // return true on success, otherwise false.
 static bool export_property(GoogleBinaryBlockUtil::PROPINDEX idx,
                             const string &filename,
                             const GoogleBinaryBlockUtil &util) {
   string prop_name = util.get_property_name(idx),
@@ skipping 44 matching lines @@
     printf(" - %s changed from '%s' to '%s': %s\n",
         prop_name.c_str(), old_value.c_str(), source.c_str(),
         result ? "success" : "failed");
     if (!result)
       return false;
   }
 
   return true;
 }
 
+static bool parse_creation_param(const string &input_string,
+                                 std::vector<uint32_t> &output_vector) {
+  const char *input = input_string.c_str();
+  char *parsed = NULL;
+  uint32_t param;
+
+  do {
+    param = (uint32_t)strtol(input, &parsed, 0);
+    if (*parsed && *parsed != ',')
+      return false;
+    output_vector.push_back(param);
+    input = parsed + 1;
+    // printf("(debug) param: %zd\n", param);
+  } while(*input);
+
+  return true;
+}
+
+static string create_new_gbb(const std::vector<uint32_t> &create_param) {

[Randall Spangler, 2011/01/07 21:47:34]

The current implementation of the GBB is done via the GoogleBinaryBlockUtil
class above.  It'd be cleaner to extend that with a create_new() method than to
have this standalone function here.

[Hung-Te, 2011/01/10 03:40:58]

Done.

+    GoogleBinaryBlockHeader header = {0};
+    uint32_t *prop = &header.hwid_offset;  // must be first entry.
+    uint32_t allocated_size = sizeof(header);
+    std::vector<uint32_t>::const_iterator i = create_param.begin();
+    string blob;
+
+    // max properties = available space in header / size of record (offset+size)
+    size_t max_properties =
+        (sizeof(header) - ((uint8_t*)prop - (uint8_t*)&header)) /
+        (sizeof(uint32_t) * 2);
+
+    if (create_param.size() >= max_properties) {
+      printf("error: creation parameters cannot exceed %zu entries.\n",
+             max_properties);
+      return blob;
+    }
+
+    memcpy(header.signature, GBB_SIGNATURE, GBB_SIGNATURE_SIZE);
+    header.major_version = GBB_MAJOR_VER;
+    header.minor_version = GBB_MINOR_VER;
+    header.header_size = GBB_HEADER_SIZE;
+
+    while (i != create_param.end()) {
+      *prop++ = allocated_size;  // property offset
+      *prop++ = *i;  // property size
+      allocated_size += *i;
+      i++;
+    }
+
+    blob.resize(allocated_size);
+    std::copy((char*)&header, (char*)(&header + 1), blob.begin());
+    return blob;
+}
+
 ///////////////////////////////////////////////////////////////////////
 // main
 
 int main(int argc, char *argv[]) {
   const char *myname = argv[0];
   int err_stage = 0;    // an indicator for error exits
 
   // small parameter helper class
   class OptPropertyMap: public
                         std::map<GoogleBinaryBlockUtil::PROPINDEX, string> {
     public:
       bool set_new_value(GoogleBinaryBlockUtil::PROPINDEX id, const string &v) {
         if (find(id) != end())
           return false;
 
         (*this)[id] = v;
         return true;
       }
   };
   OptPropertyMap opt_props;
 
   struct GBBUtilOptions {
-    bool get_mode, set_mode;
+    bool get_mode, set_mode, create_mode;
     string input_fn, output_fn;
+    std::vector<uint32_t> create_param;
   } myopts;
   myopts.get_mode = myopts.set_mode = false;

[Che-Liang Chiou, 2011/01/10 02:55:20]

I'm not sure, but doesn't myopts.create_mode have to be initialized here?

[Hung-Te, 2011/01/10 03:40:58]

My bad. fixed.

 
   // snippets for getopt_long
   int option_index, opt;
   static struct option long_options[] = {
     {"get", 0, NULL, 'g' },
     {"set", 0, NULL, 's' },
+    {"create", 0, NULL, 'c' },
     {"output", 1, NULL, 'o' },
     {"hwid", 2, NULL, 'i' },
     {"rootkey", 1, NULL, 'k' },
     {"bmpfv", 1, NULL, 'b' },
     {"recoverykey", 1, NULL, 'R' },
     { NULL, 0, NULL, 0 },
   };
 
   // parse command line options
-  while ((opt = getopt_long(argc, argv, "gso:i:k:b:",
+  while ((opt = getopt_long(argc, argv, "gsc:o:i:k:b:",
                             long_options, &option_index)) >= 0) {
     switch (opt) {
       case 'g':
         myopts.get_mode = true;
         break;
 
       case 's':
         myopts.set_mode = true;
         break;
 
+      case 'c':
+        myopts.create_mode = true;
+        {
+          const char *param = optarg ? optarg : "(empty)";
+          if (!parse_creation_param(param, myopts.create_param)) {

[Che-Liang Chiou, 2011/01/10 02:55:20]

Isn't this equivalent to "if (!optarg || !parse_creation_param(optarg,
myopts.create_param))"?

I mean, why pass a syntax incorrect argument "(empty)" to
parse_creation_param()?

[Hung-Te, 2011/01/10 03:40:58]

 Because in that case I need to put something in error message when printed
below. Blank may be confusing so I choose "(empty)".

 However, writing in this way seems tricky because it relies on "(empty)" as
invalid input. I'll fix it.

+            printf("error: invalid creation parameter: %s\n", param);
+            usagehelp_exit(myname);
+          }
+        }
+        break;
+
       case 'o':
         myopts.output_fn = optarg;
         break;
 
       case 'i':
         if (!opt_props.set_new_value(
               GoogleBinaryBlockUtil::PROP_HWID, optarg ? optarg : ""))
           usagehelp_exit(myname);
         break;
 
@@ skipping 32 matching lines @@
 
   // currently, the only parameter is 'input file'.
   if (argc == 1) {
     myopts.input_fn = argv[0];
   } else {
     usagehelp_exit(myname);
   }
 
   // stage: complete parameter parsing and checking
   err_stage++;
-  if (myopts.get_mode == myopts.set_mode) {
+  if (myopts.create_mode) {
+    if (myopts.get_mode || myopts.set_mode) {
+      printf("error: please assign only one mode from get/set/create.\n");
+      return err_stage;
+    }
+    if (!opt_props.empty() || myopts.create_param.empty()) {
+      printf("error: creation parameter syntax error.\n");
+      return err_stage;
+    }
+    if (myopts.output_fn.empty()) {
+      myopts.output_fn = myopts.input_fn;
+    }
+  } else if (myopts.get_mode == myopts.set_mode) {
     if (myopts.get_mode) {
       printf("error: please assign either get or set mode.\n");
       return err_stage;
     } else {
       // enter 'get' mode by default, if not assigned.
       myopts.get_mode = true;
     }
   }
   if (myopts.get_mode && !myopts.output_fn.empty()) {
     printf("error: get-mode does not create output files.\n");
     return err_stage;
   }
 
+  if (myopts.create_mode) {
+    // creation is not handled by GoogleBinaryBlockUtil.
+    string blob = create_new_gbb(myopts.create_param);
+
+    if (blob.empty())
+      return err_stage;
+
+    if (!write_nonempty_file(myopts.output_fn.c_str(), blob)) {
+      printf("error: cannot create to file: %s\n", myopts.output_fn.c_str());
+      return err_stage;
+    } else {
+      printf("successfully created new GBB to: %s\n", myopts.output_fn.c_str());
+    }
+    return 0;
+  }
+
   // stage: load image files
   err_stage++;
   GoogleBinaryBlockUtil util;
 
   assert(!myopts.input_fn.empty());
   if (!util.load_from_file(myopts.input_fn.c_str())) {
     printf("error: cannot load valid BIOS file: %s\n", myopts.input_fn.c_str());
     return err_stage;
   }
 
@@ skipping 47 matching lines @@
       return err_stage;
     } else {
       printf("successfully saved new image to: %s\n", myopts.output_fn.c_str());
     }
   }
 
   return 0;
 }
 
 #endif  // WITH_UTIL_MAIN