AU: Delta Diff Generator

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) {
+  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 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 59 matching lines @@
 
 bool RecursiveUnlinkDir(const std::string& path) {
   struct stat stbuf;
   int r = lstat(path.c_str(), &stbuf);
   TEST_AND_RETURN_FALSE_ERRNO((r == 0) || (errno == ENOENT));
   if ((r < 0) && (errno == ENOENT))
     // path request is missing. that's fine.
     return true;
   if (!S_ISDIR(stbuf.st_mode)) {
     TEST_AND_RETURN_FALSE_ERRNO((unlink(path.c_str()) == 0) ||
-                                 (errno == ENOENT));
+                                (errno == ENOENT));
     // success or path disappeared before we could unlink.
     return true;
   }
   {
     // We have a dir, unlink all children, then delete dir
     DIR *dir = opendir(path.c_str());
     TEST_AND_RETURN_FALSE_ERRNO(dir);
     ScopedDirCloser dir_closer(&dir);
     struct dirent dir_entry;
     struct dirent *dir_entry_p;
     int err = 0;
     while ((err = readdir_r(dir, &dir_entry, &dir_entry_p)) == 0) {
       if (dir_entry_p == NULL) {
         // end of stream reached
         break;
       }
       // Skip . and ..
       if (!strcmp(dir_entry_p->d_name, ".") ||
           !strcmp(dir_entry_p->d_name, ".."))
         continue;
       TEST_AND_RETURN_FALSE(RecursiveUnlinkDir(path + "/" +
-                                                dir_entry_p->d_name));
+                                               dir_entry_p->d_name));
     }
     TEST_AND_RETURN_FALSE(err == 0);
   }
   // unlink dir
   TEST_AND_RETURN_FALSE_ERRNO((rmdir(path.c_str()) == 0) || (errno == ENOENT));
   return true;
 }
 
 std::string ErrnoNumberAsString(int err) {
   char buf[100];
@@ skipping 44 matching lines @@
       else
         new_suffix.append(1, '0' + r - (26 * 2));
     }
     CHECK_EQ(new_suffix.size(), suffix.size());
     path.resize(path.size() - new_suffix.size());
     path.append(new_suffix);
   } while (FileExists(path.c_str()));
   return path;
 }
 
+bool MakeTempFile(const std::string& filename_template,
+                  std::string* filename,
+                  int* fd) {
+  DCHECK(filename || fd);
+  vector<char> buf(filename_template.size() + 1);
+  memcpy(&buf[0], filename_template.data(), filename_template.size());
+  buf[filename_template.size()] = '\0';
+  
+  int mkstemp_fd = mkstemp(&buf[0]);
+  TEST_AND_RETURN_FALSE_ERRNO(mkstemp_fd >= 0);
+  if (filename) {
+    *filename = &buf[0];
+  }
+  if (fd) {
+    *fd = mkstemp_fd;
+  } else {
+    close(mkstemp_fd);
+  }
+  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 42 matching lines @@
   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