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 63 matching lines @@
 }
 
 void GoogleBinaryBlockUtil::initialize() {
   verbose = true;
   is_valid_gbb = false;
   header_offset_ = 0;
   memset(&header_, 0, sizeof(header_));
   file_content_.clear();
 }
 
+bool GoogleBinaryBlockUtil::create_new(
+    const std::vector<uint32_t> &create_param) {
+  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();
+
+  // max properties = available space in header / size of record (offset+size)
+  size_t max_properties =
+      (sizeof(header_) - (reinterpret_cast<uint8_t*>(prop) -
+                          reinterpret_cast<uint8_t*>(&header_))) /
+      (sizeof(uint32_t) * 2);
+
+  if (create_param.size() >= max_properties) {
+    if (verbose)
+      fprintf(stderr, "error: creation parameters cannot exceed %zu entries.\n",
+              max_properties);
+    return false;
+  }
+
+  initialize();
+  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++;
+  }
+
+  file_content_.resize(allocated_size);
+  std::copy(reinterpret_cast<char*>(&header_),
+            reinterpret_cast<char*>(&header_ + 1),
+            file_content_.begin());
+  is_valid_gbb = true;
+  return true;
+}
+
+
 bool GoogleBinaryBlockUtil::load_from_file(const char *filename) {
   is_valid_gbb = false;
 
   file_content_ = read_nonempty_file(filename);
   if (file_content_.empty())
     return false;
 
   switch (search_header_signatures(file_content_, &header_offset_)) {
     case 0:
       if (verbose)
@@ skipping 261 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;
+
+  if (input_string.empty())
+    return false;
+
+  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;
+}
+
 ///////////////////////////////////////////////////////////////////////
 // main
 
 int main(int argc, char *argv[]) {
   const char *myname = argv[0];
   int err_stage = 0;    // an indicator for error exits
+  GoogleBinaryBlockUtil util;
 
   // 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;
+  myopts.get_mode = myopts.set_mode = myopts.create_mode = false;
 
   // snippets for getopt_long
   int option_index, opt;
   static struct option long_options[] = {
     {"get", 0, NULL, 'g' },
     {"set", 0, NULL, 's' },
+    {"create", 1, 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;
+        assert(optarg);
+        if (!*optarg || !parse_creation_param(optarg, &myopts.create_param)) {
+          printf("error: invalid creation parameter: %s\n", optarg);
+          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) {
+    if (!util.create_new(myopts.create_param))
+      return err_stage;
+
+    assert(!myopts.output_fn.empty());
+    if (!util.save_to_file(myopts.output_fn.c_str())) {
+      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;
   }
 
   // stage: processing by mode
   err_stage++;
   if (myopts.get_mode) {
     // get mode
@@ skipping 43 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