AU: Verify source rootfs/kernel hashes before applying delta.

filesystem_copier_action.h

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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_FILESYSTEM_COPIER_ACTION_H__
 #define CHROMEOS_PLATFORM_UPDATE_ENGINE_FILESYSTEM_COPIER_ACTION_H__
 
 #include <sys/stat.h>
 #include <sys/types.h>
+
 #include <string>
 #include <vector>
+
 #include <gio/gio.h>
 #include <glib.h>
+#include <gtest/gtest_prod.h>  // for FRIEND_TEST
+
 #include "update_engine/action.h"
 #include "update_engine/install_plan.h"
+#include "update_engine/omaha_hash_calculator.h"
 
 // This action will only do real work if it's a delta update. It will
 // copy the root partition to install partition, and then terminate.
 
 namespace chromeos_update_engine {
 
 class FilesystemCopierAction;
 
 template<>
 class ActionTraits<FilesystemCopierAction> {
  public:
   // Takes the install plan as input
   typedef InstallPlan InputObjectType;
   // Passes the install plan as output
   typedef InstallPlan OutputObjectType;
 };
 
 class FilesystemCopierAction : public Action<FilesystemCopierAction> {
  public:
   explicit FilesystemCopierAction(bool copying_kernel_install_path)
       : copying_kernel_install_path_(copying_kernel_install_path),
         src_stream_(NULL),
         dst_stream_(NULL),
         canceller_(NULL),
         read_in_flight_(false),
-        buffer_valid_size_(0) {}
+        buffer_valid_size_(0),
+        filesystem_size_(kint64max) {}
   typedef ActionTraits<FilesystemCopierAction>::InputObjectType
   InputObjectType;
   typedef ActionTraits<FilesystemCopierAction>::OutputObjectType
   OutputObjectType;
   void PerformAction();
   void TerminateProcessing();
 
   // Used for testing, so we can copy from somewhere other than root
   void set_copy_source(const std::string& path) {
     copy_source_ = path;
   }
 
   // Debugging/logging
   static std::string StaticType() { return "FilesystemCopierAction"; }
   std::string Type() const { return StaticType(); }
 
  private:
+  friend class FilesystemCopierActionTest;
+  FRIEND_TEST(FilesystemCopierActionTest, RunAsRootDetermineFilesystemSizeTest);
+
   // Callback from glib when the copy operation is done.
   void AsyncReadyCallback(GObject *source_object, GAsyncResult *res);
   static void StaticAsyncReadyCallback(GObject *source_object,
                                        GAsyncResult *res,
                                        gpointer user_data) {
     reinterpret_cast<FilesystemCopierAction*>(user_data)->AsyncReadyCallback(
         source_object, res);
   }
-  
+
   // Cleans up all the variables we use for async operations and tells
   // the ActionProcessor we're done w/ success as passed in.
   // was_cancelled should be true if TerminateProcessing() was called.
   void Cleanup(bool success, bool was_cancelled);
-  
+
+  // Determine, if possible, the source file system size to avoid copying the
+  // whole partition. Currently this supports only the root file system assuming
+  // it's ext3-compatible.
+  void DetermineFilesystemSize(int fd);
+
+  // Returns the number of bytes to read based on the size of the buffer and the
+  // filesystem size.
+  int64_t GetBytesToRead();
+
   // If true, this action is copying to the kernel_install_path from
   // the install plan, otherwise it's copying just to the install_path.
   const bool copying_kernel_install_path_;
-  
+
   // The path to copy from. If empty (the default), the source is from the
   // passed in InstallPlan.
   std::string copy_source_;
 
   // If non-NULL, these are GUnixInputStream objects for the opened
   // source/destination partitions.
   GInputStream* src_stream_;
   GOutputStream* dst_stream_;
-  
+
   // If non-NULL, the cancellable object for the in-flight async call.
   GCancellable* canceller_;
-  
+
   // True if we're waiting on a read to complete; false if we're
   // waiting on a write.
   bool read_in_flight_;
-  
+
   // The buffer for storing data we read/write.
   std::vector<char> buffer_;
 
   // Number of valid elements in buffer_.
   std::vector<char>::size_type buffer_valid_size_;
 
   // The install plan we're passed in via the input pipe.
   InstallPlan install_plan_;
-  
+
+  // Calculates the hash of the copied data.
+  OmahaHashCalculator hasher_;
+
+  // Copies and hashes this many bytes from the head of the input stream. This
+  // field is initialized when the action is started and decremented as more
+  // bytes get copied.
+  int64_t filesystem_size_;
+
   DISALLOW_COPY_AND_ASSIGN(FilesystemCopierAction);
 };
 
 }  // namespace chromeos_update_engine
 
 #endif  // CHROMEOS_PLATFORM_UPDATE_ENGINE_FILESYSTEM_COPIER_ACTION_H__