AU: Include the old/new kernel/rootfs size/hash in the update metadata.

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>
 #include <openssl/bio.h>
 #include <openssl/buffer.h>
 #include <openssl/evp.h>
-#include "base/logging.h"
+
 #include "update_engine/utils.h"
 
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 OmahaHashCalculator::OmahaHashCalculator() : valid_(false) {
   valid_ = (SHA256_Init(&ctx_) == 1);
   LOG_IF(ERROR, !valid_) << "SHA256_Init failed";
 }
 
 // Update is called with all of the data that should be hashed in order.
 // Mostly just passes the data through to OpenSSL's SHA256_Update()
 bool OmahaHashCalculator::Update(const char* data, size_t length) {
   TEST_AND_RETURN_FALSE(valid_);
   TEST_AND_RETURN_FALSE(hash_.empty());
   COMPILE_ASSERT(sizeof(size_t) <= sizeof(unsigned long),
                  length_param_may_be_truncated_in_SHA256_Update);
   TEST_AND_RETURN_FALSE(SHA256_Update(&ctx_, data, length) == 1);
   return true;
 }
 
+off_t OmahaHashCalculator::UpdateFile(const string& name, off_t length) {
+  int fd = HANDLE_EINTR(open(name.c_str(), O_RDONLY));
+  if (fd < 0) {
+    return -1;
+  }
+
+  const int kBufferSize = 128 * 1024;  // 128 KiB
+  vector<char> buffer(kBufferSize);
+  off_t bytes_processed = 0;
+  while (length < 0 || bytes_processed < length) {
+    off_t bytes_to_read = buffer.size();
+    if (length >= 0 && bytes_to_read > length - bytes_processed) {
+      bytes_to_read = length - bytes_processed;
+    }
+    ssize_t rc = HANDLE_EINTR(read(fd, &buffer[0], bytes_to_read));

[adlr, 2010/10/08 01:21:58]

I never heard of HANDLE_EINTR and just looked it up. What's the deal w/ it?

[petkov, 2010/10/08 04:14:29]

open/read/close can theoretically (but somewhat unlikely) be  interrupted by
system calls and return -1 with errno set to EINTR. In these cases you have to
reinvoke the calls. HANDLE_EINTR is a macro in libbase that wraps the system
calls so you don't have to explicitly check and re-invoke them when they're
interrupted -- it does it for you.

+    if (rc == 0) {  // EOF
+      break;
+    }
+    if (rc < 0 || !Update(&buffer[0], 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 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);
@@ skipping 57 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