AU: Add support for signing of update payloads after they're generated.

delta_performer.h

 // 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.
 
 #ifndef CHROMEOS_PLATFORM_UPDATE_ENGINE_DELTA_PERFORMER_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_DELTA_PERFORMER_H__
 
 #include <inttypes.h>
 
 #include <vector>
 
 #include <google/protobuf/repeated_field.h>
 #include <gtest/gtest_prod.h>  // for FRIEND_TEST
 
 #include "update_engine/file_writer.h"
 #include "update_engine/omaha_hash_calculator.h"
 #include "update_engine/update_metadata.pb.h"
 
 namespace chromeos_update_engine {
 
 class PrefsInterface;
 
 // This class performs the actions in a delta update synchronously. The delta
 // update itself should be passed in in chunks as it is received.
 
 class DeltaPerformer : public FileWriter {
  public:
+  enum MetadataParseResult {
+    kMetadataParseSuccess,
+    kMetadataParseError,
+    kMetadataParseInsufficientData,
+  };
+
   DeltaPerformer(PrefsInterface* prefs)
       : prefs_(prefs),
         fd_(-1),
         kernel_fd_(-1),
         manifest_valid_(false),
         manifest_metadata_size_(0),
         next_operation_num_(0),
         buffer_offset_(0),
         last_updated_buffer_offset_(kuint64max),
         block_size_(0) {}
@@ skipping 55 matching lines @@
   // persistent preferences and the new update check response hash.
   static bool CanResumeUpdate(PrefsInterface* prefs,
                               std::string update_check_response_hash);
 
   // Resets the persistent update progress state to indicate that an update
   // can't be resumed. Performs a quick update-in-progress reset if |quick| is
   // true, otherwise resets all progress-related update state. Returns true on
   // success, false otherwise.
   static bool ResetUpdateProgress(PrefsInterface* prefs, bool quick);
 
+  // Attempts to parse the update metadata starting from the beginning of
+  // |payload| into |manifest|. On success, sets |metadata_size| to the total
+  // metadata bytes (including the delta magic and metadata size fields), and
+  // returns kMetadataParseSuccess. Returns kMetadataParseInsufficientData if
+  // more data is needed to parse the complete metadata. Returns
+  // kMetadataParseError if the metadata can't be parsed given the payload.
+  static MetadataParseResult ParsePayloadMetadata(
+      const std::vector<char>& payload,
+      DeltaArchiveManifest* manifest,
+      uint64_t* metadata_size);
+
   void set_current_kernel_hash(const std::vector<char>& hash) {
     current_kernel_hash_ = hash;
   }
 
   void set_current_rootfs_hash(const std::vector<char>& hash) {
     current_rootfs_hash_ = hash;
   }
 
  private:
   friend class DeltaPerformerTest;
@@ skipping 92 matching lines @@
   // verification.
   std::vector<char> current_kernel_hash_;
   std::vector<char> current_rootfs_hash_;
 
   DISALLOW_COPY_AND_ASSIGN(DeltaPerformer);
 };
 
 }  // namespace chromeos_update_engine
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_DELTA_PERFORMER_H__