libmetrics: Support partial writes.

metrics_library.cc

 // 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.
 
 #include "metrics_library.h"
 
 #include <errno.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 
 #include <cstdarg>
 #include <cstdio>
 #include <cstring>
 
-#include <base/eintr_wrapper.h>
+#include "base/eintr_wrapper.h"  // HANDLE_EINTR macro, no libbase required.
 
 #define READ_WRITE_ALL_FILE_FLAGS \
   (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
 
 static const char kAutotestPath[] = "/var/log/metrics/autotest-events";
 static const char kUMAEventsPath[] = "/var/log/metrics/uma-events";
 static const char kConsentFile[] = "/home/chronos/Consent To Send Stats";
 static const int32_t kBufferSize = 1024;
 
 time_t MetricsLibrary::cached_enabled_time_ = 0;
 bool MetricsLibrary::cached_enabled_ = false;
 
 using std::string;
 
 // TODO(sosa@chromium.org) - use Chromium logger instead of stderr
 static void PrintError(const char* message, const char* file,
                        int code) {
   static const char kProgramName[] = "libmetrics";
   if (code == 0) {
     fprintf(stderr, "%s: %s\n", kProgramName, message);
   } else if (file == NULL) {
     fprintf(stderr, "%s: ", kProgramName);
     perror(message);
   } else {
     fprintf(stderr, "%s: %s: ", kProgramName, file);
     perror(message);
   }
 }
 
+// Copied from libbase to avoid pulling in all of libbase just for libmetrics.
+static int WriteFileDescriptor(const int fd, const char* data, int size) {
+  // Allow for partial writes.
+  ssize_t bytes_written_total = 0;
+  for (ssize_t bytes_written_partial = 0; bytes_written_total < size;
+       bytes_written_total += bytes_written_partial) {
+    bytes_written_partial =
+        HANDLE_EINTR(write(fd, data + bytes_written_total,
+                           size - bytes_written_total));
+    if (bytes_written_partial < 0)
+      return -1;
+  }
+
+  return bytes_written_total;
+}
+
 MetricsLibrary::MetricsLibrary()
     : uma_events_file_(NULL),
       consent_file_(kConsentFile) {}
 
 // We take buffer and buffer_size as parameters in order to simplify testing
 // of various alignments of the |device_name| with |buffer_size|.
 bool MetricsLibrary::IsDeviceMounted(const char* device_name,
                                      const char* mounts_file,
                                      char* buffer,
                                      int buffer_size,
@@ skipping 93 matching lines @@
 
   // Grab an exclusive lock to protect Chrome from truncating
   // underneath us. Keep the file locked as briefly as possible.
   if (HANDLE_EINTR(flock(chrome_fd, LOCK_EX)) < 0) {
     PrintError("flock", uma_events_file_, errno);
     HANDLE_EINTR(close(chrome_fd));
     return false;
   }
 
   bool success = true;
-  if (HANDLE_EINTR(write(chrome_fd, message, length)) != length) {
+  if (WriteFileDescriptor(chrome_fd, message, length) != length) {
     PrintError("write", uma_events_file_, errno);
     success = false;
   }
 
   // Close the file and release the lock.
   HANDLE_EINTR(close(chrome_fd));
   return success;
 }
 
 int32_t MetricsLibrary::FormatChromeMessage(int32_t buffer_size, char* buffer,
@@ skipping 91 matching lines @@
   int32_t message_length =
       FormatChromeMessage(kBufferSize, message,
                           "crash%c%s", '\0', crash_kind);
 
   if (message_length < 0)
     return false;
 
   // Send the message.
   return SendMessageToChrome(message_length, message);
 }