AU: When applying delta locally, get source checksums

delta_performer.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.
 
 #include "update_engine/delta_performer.h"
 
 #include <endian.h>
 #include <errno.h>
 
 #include <algorithm>
@@ skipping 147 matching lines @@
   if (close(fd_) == -1) {
     err = errno;
     PLOG(ERROR) << "Unable to close rootfs fd:";
   }
   LOG_IF(ERROR, !hash_calculator_.Finalize()) << "Unable to finalize the hash.";
   fd_ = -2;  // Set so that isn't not valid AND calls to Open() will fail.
   path_ = "";
   return -err;
 }
 
+namespace {
+void LogPartitionInfoHash(const PartitionInfo& info, const string& tag) {
+  string sha256;
+  if (OmahaHashCalculator::Base64Encode(info.hash().data(),
+                                        info.hash().size(),
+                                        &sha256)) {
+    LOG(INFO) << "PartitionInfo " << tag << " sha256:" << sha256
+              << " length:" << tag.size();
+  } else {
+    LOG(ERROR) << "Base64Encode failed for tag: " << tag;
+  }
+}
+void LogPartitionInfo(const DeltaArchiveManifest& manifest) {

[petkov, 2010/10/22 20:15:16]

add blank line before

[adlr, 2010/10/22 20:40:18]

Done.

+  if (manifest.has_old_kernel_info())
+    LogPartitionInfoHash(manifest.old_kernel_info(), "old_kernel_info");
+  if (manifest.has_old_rootfs_info())
+    LogPartitionInfoHash(manifest.old_rootfs_info(), "old_rootfs_info");
+  if (manifest.has_new_kernel_info())
+    LogPartitionInfoHash(manifest.new_kernel_info(), "new_kernel_info");
+  if (manifest.has_new_rootfs_info())
+    LogPartitionInfoHash(manifest.new_rootfs_info(), "new_rootfs_info");
+}
+}  // namespace {}
+
 // Wrapper around write. Returns bytes written on success or
 // -errno on error.
 // This function performs as many actions as it can, given the amount of
 // data received thus far.
 ssize_t DeltaPerformer::Write(const void* bytes, size_t count) {
   const char* c_bytes = reinterpret_cast<const char*>(bytes);
   buffer_.insert(buffer_.end(), c_bytes, c_bytes + count);
 
   if (!manifest_valid_) {
     // See if we have enough bytes for the manifest yet
@@ skipping 22 matching lines @@
     }
     // Remove protobuf and header info from buffer_, so buffer_ contains
     // just data blobs
     manifest_metadata_size_ = strlen(kDeltaMagic) + kDeltaVersionLength +
         kDeltaProtobufLengthLength + protobuf_length;
     DiscardBufferHeadBytes(manifest_metadata_size_);
     LOG_IF(WARNING, !prefs_->SetInt64(kPrefsManifestMetadataSize,
                                       manifest_metadata_size_))
         << "Unable to save the manifest metadata size.";
     manifest_valid_ = true;
+    LogPartitionInfo(manifest_);
     if (!PrimeUpdateState()) {
       LOG(ERROR) << "Unable to prime the update state.";
       return -EINVAL;
     }
   }
   ssize_t total_operations = manifest_.install_operations_size() +
       manifest_.kernel_install_operations_size();
   while (next_operation_num_ < total_operations) {
     const DeltaArchiveManifest_InstallOperation &op =
         next_operation_num_ < manifest_.install_operations_size() ?
@@ skipping 496 matching lines @@
   if (prefs_->GetInt64(kPrefsResumedUpdateFailures, &resumed_update_failures)) {
     resumed_update_failures++;
   } else {
     resumed_update_failures = 1;
   }
   prefs_->SetInt64(kPrefsResumedUpdateFailures, resumed_update_failures);
   return true;
 }
 
 }  // namespace chromeos_update_engine