AU: When applying delta locally, get source checksums

omaha_hash_calculator.cc

 // Copyright (c) 2009 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/omaha_hash_calculator.h"
 
 #include <fcntl.h>
 
 #include <base/eintr_wrapper.h>
 #include <base/logging.h>
@@ skipping 45 matching lines @@
     if (rc < 0 || !Update(buffer.data(), rc)) {
       bytes_processed = -1;
       break;
     }
     bytes_processed += rc;
   }
   HANDLE_EINTR(close(fd));
   return bytes_processed;
 }
 
-// Call Finalize() when all data has been passed in. This mostly just
-// calls OpenSSL's SHA256_Final() and then base64 encodes the hash.
-bool OmahaHashCalculator::Finalize() {
+bool OmahaHashCalculator::Base64Encode(const void* data,
+                                       size_t size,
+                                       string* out) {
   bool success = true;
-  TEST_AND_RETURN_FALSE(hash_.empty());
-  TEST_AND_RETURN_FALSE(raw_hash_.empty());
-  raw_hash_.resize(SHA256_DIGEST_LENGTH);
-  TEST_AND_RETURN_FALSE(
-      SHA256_Final(reinterpret_cast<unsigned char*>(&raw_hash_[0]),
-                   &ctx_) == 1);
-
-  // Convert raw_hash_ to base64 encoding and store it in hash_.
   BIO *b64 = BIO_new(BIO_f_base64());
   if (!b64)
     LOG(INFO) << "BIO_new(BIO_f_base64()) failed";
   BIO *bmem = BIO_new(BIO_s_mem());
   if (!bmem)
     LOG(INFO) << "BIO_new(BIO_s_mem()) failed";
   if (b64 && bmem) {
     b64 = BIO_push(b64, bmem);
     success =
-        (BIO_write(b64, &raw_hash_[0], raw_hash_.size()) ==
-         static_cast<int>(raw_hash_.size()));
+        (BIO_write(b64, data, size) == static_cast<int>(size));
     if (success)
       success = (BIO_flush(b64) == 1);
 
     BUF_MEM *bptr = NULL;
     BIO_get_mem_ptr(b64, &bptr);
-    hash_.assign(bptr->data, bptr->length - 1);
+    out->assign(bptr->data, bptr->length - 1);
   }
   if (b64) {
     BIO_free_all(b64);
     b64 = NULL;
   }
   return success;
 }
 
+// Call Finalize() when all data has been passed in. This mostly just
+// calls OpenSSL's SHA256_Final() and then base64 encodes the hash.
+bool OmahaHashCalculator::Finalize() {
+  TEST_AND_RETURN_FALSE(hash_.empty());
+  TEST_AND_RETURN_FALSE(raw_hash_.empty());
+  raw_hash_.resize(SHA256_DIGEST_LENGTH);
+  TEST_AND_RETURN_FALSE(
+      SHA256_Final(reinterpret_cast<unsigned char*>(&raw_hash_[0]),
+                   &ctx_) == 1);
+
+  // Convert raw_hash_ to base64 encoding and store it in hash_.
+  return OmahaHashCalculator::Base64Encode(&raw_hash_[0],

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

You don't need OmahaHashCalculator:: I think.

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

Done.

+                                           raw_hash_.size(),
+                                           &hash_);;
+}
+
 bool OmahaHashCalculator::RawHashOfData(const vector<char>& data,
                                         vector<char>* out_hash) {
   OmahaHashCalculator calc;
   calc.Update(&data[0], data.size());
 
   out_hash->resize(out_hash->size() + SHA256_DIGEST_LENGTH);
   TEST_AND_RETURN_FALSE(
       SHA256_Final(reinterpret_cast<unsigned char*>(&(*(out_hash->end() -
                                                         SHA256_DIGEST_LENGTH))),
                    &calc.ctx_) == 1);
@@ skipping 34 matching lines @@
   return string(reinterpret_cast<const char*>(&ctx_), sizeof(ctx_));
 }
 
 bool OmahaHashCalculator::SetContext(const std::string& context) {
   TEST_AND_RETURN_FALSE(context.size() == sizeof(ctx_));
   memcpy(&ctx_, context.data(), sizeof(ctx_));
   return true;
 }
 
 }  // namespace chromeos_update_engine