AU: Class to perform delta updates.

src/platform/update_engine/utils.cc

 // Copyright (c) 2009 The Chromium 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/utils.h"
 #include <sys/mount.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <dirent.h>
 #include <errno.h>
@@ skipping 17 matching lines @@
 bool WriteFile(const char* path, const char* data, int data_len) {
   DirectFileWriter writer;
   TEST_AND_RETURN_FALSE_ERRNO(0 == writer.Open(path,
                                                O_WRONLY | O_CREAT | O_TRUNC,
                                                0666));
   ScopedFileWriterCloser closer(&writer);
   TEST_AND_RETURN_FALSE_ERRNO(data_len == writer.Write(data, data_len));
   return true;
 }
 
-bool WriteAll(int fd, const void *buf, size_t count) {
+bool WriteAll(int fd, const void* buf, size_t count) {
   const char* c_buf = static_cast<const char*>(buf);
   ssize_t bytes_written = 0;
   while (bytes_written < static_cast<ssize_t>(count)) {
     ssize_t rc = write(fd, c_buf + bytes_written, count - bytes_written);
     TEST_AND_RETURN_FALSE_ERRNO(rc >= 0);
     bytes_written += rc;
   }
   return true;
 }
 
+bool PWriteAll(int fd, const void* buf, size_t count, off_t offset) {
+  const char* c_buf = static_cast<const char*>(buf);
+  ssize_t bytes_written = 0;
+  while (bytes_written < static_cast<ssize_t>(count)) {
+    ssize_t rc = pwrite(fd, c_buf + bytes_written, count - bytes_written,
+                        offset + bytes_written);
+    TEST_AND_RETURN_FALSE_ERRNO(rc >= 0);
+    bytes_written += rc;
+  }
+  return true;
+}
+
+bool PReadAll(int fd, void* buf, size_t count, off_t offset,
+              ssize_t* out_bytes_read) {
+  char* c_buf = static_cast<char*>(buf);
+  ssize_t bytes_read = 0;
+  while (bytes_read < static_cast<ssize_t>(count)) {
+    ssize_t rc = pread(fd, c_buf + bytes_read, count - bytes_read,
+                       offset + bytes_read);
+    TEST_AND_RETURN_FALSE_ERRNO(rc >= 0);
+    if (rc == 0) {
+      break;
+    }
+    bytes_read += rc;
+  }
+  *out_bytes_read = bytes_read;
+  return true;
+  
+}
+
 bool ReadFile(const std::string& path, std::vector<char>* out) {
   CHECK(out);
   FILE* fp = fopen(path.c_str(), "r");
   if (!fp)
     return false;
   const size_t kChunkSize = 1024;
   size_t read_size;
   do {
     char buf[kChunkSize];
     read_size = fread(buf, 1, kChunkSize, fp);
@@ skipping 167 matching lines @@
     *filename = &buf[0];
   }
   if (fd) {
     *fd = mkstemp_fd;
   } else {
     close(mkstemp_fd);
   }
   return true;
 }
 
+bool MakeTempDirectory(const std::string& dirname_template,
+                       std::string* dirname) {
+  DCHECK(dirname);
+  vector<char> buf(dirname_template.size() + 1);
+  memcpy(&buf[0], dirname_template.data(), dirname_template.size());
+  buf[dirname_template.size()] = '\0';
+  
+  char* return_code = mkdtemp(&buf[0]);
+  TEST_AND_RETURN_FALSE_ERRNO(return_code != NULL);
+  *dirname = &buf[0];
+  return true;
+}
+
 bool StringHasSuffix(const std::string& str, const std::string& suffix) {
   if (suffix.size() > str.size())
     return false;
   return 0 == str.compare(str.size() - suffix.size(), suffix.size(), suffix);
 }
 
 bool StringHasPrefix(const std::string& str, const std::string& prefix) {
   if (prefix.size() > str.size())
     return false;
   return 0 == str.compare(0, prefix.size(), prefix);
@@ skipping 20 matching lines @@
     if (c == ' ')
       break;
     ret += c;
     pos++;
   }
   return ret;
   // TODO(adlr): use findfs to figure out UUID= or LABEL= filesystems
 }
 
 bool MountFilesystem(const string& device,
-                     const string& mountpoint) {
-  int rc = mount(device.c_str(), mountpoint.c_str(), "ext3", 0, NULL);
+                     const string& mountpoint,
+                     unsigned long mountflags) {
+  int rc = mount(device.c_str(), mountpoint.c_str(), "ext3", mountflags, NULL);
   if (rc < 0) {
     string msg = ErrnoNumberAsString(errno);
     LOG(ERROR) << "Unable to mount destination device: " << msg << ". "
                << device << " on " << mountpoint;
     return false;
   }
   return true;
 }
 
 bool UnmountFilesystem(const string& mountpoint) {
   TEST_AND_RETURN_FALSE_ERRNO(umount(mountpoint.c_str()) == 0);
   return true;
 }
 
 const char* const kStatefulPartition = "/mnt/stateful_partition";
 
 }  // namespace utils
 
 }  // namespace chromeos_update_engine