Add 'recovery_key' in Google Binary Block (GBB) utility

src/platform/vboot_reference/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>
@@ skipping 239 matching lines @@
         *pname = "root_key";
       break;
 
     case PROP_BMPFV:
       *poffset = header_.bmpfv_offset;
       *psize = header_.bmpfv_size;
       if (pname)
         *pname = "bmp_fv";
       break;
 
+    case PROP_RCVKEY:
+      *poffset = header_.recovery_key_offset;;
+      *psize = header_.recovery_key_size;
+      if (pname)
+        *pname = "recovery_key";
+      break;
+
     default:
+      if (verbose) {
+        fprintf(stderr, " internal error: unknown property (%d).\n",
+            static_cast<int>(i));
+      }
       assert(!"invalid property index.");
       return false;
   }
 
   return true;
 }
 
 bool GoogleBinaryBlockUtil::set_property(PROPINDEX i, const string &value) {
   uint32_t prop_size;
   uint32_t prop_offset;
   const char *prop_name;
 
   assert(is_valid_gbb);
 
-  if (!find_property(i, &prop_offset, &prop_size, &prop_name)) {
-    if (verbose)
-      fprintf(stderr, " internal error: unknown property (%d).\n",
-              static_cast<int>(i));
+  if (!find_property(i, &prop_offset, &prop_size, &prop_name))
     return false;
-  }
 
   if (prop_size < value.size()) {
     if (verbose)
       fprintf(stderr, " error: value size (%zu) exceed property capacity "
               "(%u): %s\n", value.size(), prop_size, prop_name);
     return false;
   }
 
   if (i == PROP_HWID && prop_size == value.size()) {
     // special case: this is NUL-terminated so it's better to keep one more \0
@@ skipping 10 matching lines @@
   return true;
 }
 
 string GoogleBinaryBlockUtil::get_property(PROPINDEX i) const {
   uint32_t prop_size;
   uint32_t prop_offset;
   const char *prop_name;
 
   assert(is_valid_gbb);
 
-  if (!find_property(i, &prop_offset, &prop_size, &prop_name)) {
-    if (verbose)
-      fprintf(stderr, " internal error: unknown property (%d).\n",
-              static_cast<int>(i));
+  if (!find_property(i, &prop_offset, &prop_size, &prop_name))
     return "";
-  }
 
   // check range again to allow empty value (for compatbility)
   if (prop_offset == 0 && prop_size == 0) {
     if (verbose)
       fprintf(stderr, " warning: empty property (%d): %s.\n",
               static_cast<int>(i), prop_name);
     return "";
   }
 
   string::const_iterator dest = file_content_.begin() +
                                 header_offset_ + prop_offset;
   return string(dest, dest + prop_size);
 }
 
 string GoogleBinaryBlockUtil::get_property_name(PROPINDEX i) const {
   uint32_t unused_off, unused_size;
   const char *prop_name;
 
   if (!find_property(i, &unused_off, &unused_size, &prop_name)) {
-    if (verbose)
-      fprintf(stderr, " internal error: unknown property (%d).\n",
-          static_cast<int>(i));
     assert(!"invalid property index.");
     return "";
   }
 
   return prop_name;
 }
 
 bool GoogleBinaryBlockUtil::set_hwid(const char *hwid) {
   return set_property(PROP_HWID, hwid);
 }
 
 bool GoogleBinaryBlockUtil::set_rootkey(const std::string &value) {
   return set_property(PROP_ROOTKEY, value);
 }
 
 bool GoogleBinaryBlockUtil::set_bmpfv(const string &value) {
   return set_property(PROP_BMPFV, value);
 }
 
+bool GoogleBinaryBlockUtil::set_recovery_key(const string &value) {
+  return set_property(PROP_RCVKEY, value);
+}
+
 }  // namespace vboot_reference
 
 #ifdef WITH_UTIL_MAIN
 
 ///////////////////////////////////////////////////////////////////////
 // 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"
     "\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"
     "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);
   exit(1);
 }
 
 // utility function: export a property from GBB to given file.
 // if filename was empty, export to console (screen).
@@ skipping 84 matching lines @@
 
   // snippets for getopt_long
   int option_index, opt;
   static struct option long_options[] = {
     {"get", 0, NULL, 'g' },
     {"set", 0, NULL, 's' },
     {"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:",
                             long_options, &option_index)) >= 0) {
     switch (opt) {
       case 'g':
         myopts.get_mode = true;
         break;
@@ skipping 17 matching lines @@
               GoogleBinaryBlockUtil::PROP_ROOTKEY, optarg))
           usagehelp_exit(myname);
         break;
 
       case 'b':
         if (!opt_props.set_new_value(
               GoogleBinaryBlockUtil::PROP_BMPFV, optarg))
           usagehelp_exit(myname);
         break;
 
+      case 'R':
+        if (!opt_props.set_new_value(
+              GoogleBinaryBlockUtil::PROP_RCVKEY, optarg))
+          usagehelp_exit(myname);
+        break;
+
       default:
       case '?':
         usagehelp_exit(myname);
         break;
     }
   }
   argc -= optind;
   argv += optind;
 
   // adjust non-dashed parameters
@@ skipping 86 matching lines @@
     } else {
       printf("successfully saved new image to: %s\n", myopts.output_fn.c_str());
     }
   }
 
   return 0;
 }
 
 #endif  // WITH_UTIL_MAIN