Adds USB writing for OS X.

chrome/utility/image_writer/image_writer_mac.cc

Index: chrome/utility/image_writer/image_writer_mac.cc
diff --git a/chrome/utility/image_writer/image_writer_mac.cc b/chrome/utility/image_writer/image_writer_mac.cc
new file mode 100644
index 0000000000000000000000000000000000000000..0a5f2e637f744d3692845668fd95ecc300615d12
--- /dev/null
+++ b/chrome/utility/image_writer/image_writer_mac.cc
@@ -0,0 +1,158 @@
+// Copyright 2014 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 <sys/socket.h>
+#include <IOKit/storage/IOStorageProtocolCharacteristics.h>
+
+#include "base/command_line.h"
+#include "base/files/scoped_file.h"
+#include "base/posix/eintr_wrapper.h"
+#include "base/process/kill.h"
+#include "base/process/launch.h"
+#include "base/strings/stringprintf.h"
+#include "chrome/utility/image_writer/disk_unmounter_mac.h"
+#include "chrome/utility/image_writer/error_messages.h"
+#include "chrome/utility/image_writer/image_writer.h"
+
+namespace image_writer {
+
+static const char* kAuthOpenPath = "/usr/libexec/authopen";

[Robert Sesek, 2014/06/12 22:01:34]

Use const char kAuthOpenPath[] = "..."; instead to avoid creating a static
initializer.

[Drew Haven, 2014/06/12 22:55:10]

Done.

+
+bool ImageWriter::IsValidDevice() {
+  base::ScopedCFTypeRef<DASessionRef> session(DASessionCreate(NULL));
+  base::ScopedCFTypeRef<DADiskRef> disk(DADiskCreateFromBSDName(
+      kCFAllocatorDefault, session, device_path_.value().c_str()));
+
+  if (!disk)
+    return false;
+
+  base::ScopedCFTypeRef<CFDictionaryRef> disk_description(
+      DADiskCopyDescription(disk));
+
+  CFBooleanRef ejectable = base::mac::GetValueFromDictionary<CFBooleanRef>(
+      disk_description, kDADiskDescriptionMediaEjectableKey);
+  CFBooleanRef removable = base::mac::GetValueFromDictionary<CFBooleanRef>(
+      disk_description, kDADiskDescriptionMediaRemovableKey);
+  CFBooleanRef writable = base::mac::GetValueFromDictionary<CFBooleanRef>(
+      disk_description, kDADiskDescriptionMediaWritableKey);
+  CFBooleanRef whole = base::mac::GetValueFromDictionary<CFBooleanRef>(
+      disk_description, kDADiskDescriptionMediaWholeKey);
+  CFStringRef kind = base::mac::GetValueFromDictionary<CFStringRef>(
+      disk_description, kDADiskDescriptionMediaKindKey);
+
+  // A drive is valid if it is
+  // - ejectable
+  // - removable
+  // - writable
+  // - a whole drive
+  // - it is of type IOMedia (external DVD drives and the like are IOCDMedia or
+  //   IODVDMedia)
+  return CFBooleanGetValue(ejectable) && CFBooleanGetValue(removable) &&
+         CFBooleanGetValue(writable) && CFBooleanGetValue(whole) &&
+         CFStringCompare(kind, CFSTR("IOMedia"), 0) == kCFCompareEqualTo;
+}
+
+void ImageWriter::UnmountVolumes(const base::Closure& continuation) {
+  if (unmounter_ == NULL) {
+    unmounter_.reset(new DiskUnmounterMac());
+  }
+
+  unmounter_->Unmount(
+      device_path_.value(),
+      continuation,
+      base::Bind(
+          &ImageWriter::Error, base::Unretained(this), error::kUnmountVolumes));
+}
+
+bool ImageWriter::OpenDevice() {
+  base::LaunchOptions options = base::LaunchOptions();
+  options.wait = false;
+
+  // Create a socket pair for communication.
+  int sockets[2];
+  int result = socketpair(AF_UNIX, SOCK_STREAM, 0, sockets);
+  if (result == -1) {
+    LOG(ERROR) << "Unable to allocate socket pair.";
+    return false;
+  }
+  base::ScopedFD parent_socket(sockets[0]);
+  base::ScopedFD child_socket(sockets[1]);
+
+  // Map the client socket to the client's STDOUT.
+  base::FileHandleMappingVector fd_map;
+  fd_map.push_back(
+      std::pair<int, int>(child_socket.get(), STDOUT_FILENO));
+  options.fds_to_remap = &fd_map;
+
+  // Find the file path to open.
+  base::FilePath real_device_path;
+  if (device_path_.IsAbsolute()) {
+    real_device_path = device_path_;
+  } else {
+    real_device_path = base::FilePath("/dev").Append(device_path_);
+  }
+
+  // Build the command line.
+  std::string rdwr = base::StringPrintf("%d", O_RDWR);
+
+  base::CommandLine cmd_line((base::FilePath(kAuthOpenPath)));

[Robert Sesek, 2014/06/12 22:01:34]

I have two minds about this authopen stuff. On the one hand, it seems fairly
straightforward. On the other hand, the truly correct way to do this would be
with Authorization Services/Security Framework:

https://developer.apple.com/library/mac/documentation/security/Conceptual/aut...

I don't have much familiarity with that framework, though, so I'm a bit hesitant
to send you down an unknown path.

[Robert Sesek, 2014/06/12 22:01:35]

nit: double parens around this

[Drew Haven, 2014/06/12 22:55:10]

That was actually prompted by the compiler because a single-parens is
interpreted as a function declaration.  Maybe we have a policy of always doing
an assignment for variable initialization?

[Drew Haven, 2014/06/12 22:55:10]

At this point I'd like to just go with this implementation since it's fairly
straight forward.  Yet another library to learn might cause my brain to explode.
 I just went from what the recovery tool was doing.

[Robert Sesek, 2014/06/16 19:32:53]

Yes, double parens look weird here. Use assignment instead.

+  cmd_line.AppendSwitch("-stdoutpipe");
+  // Using AppendSwitchNative will use an equal-symbol which we don't want.
+  cmd_line.AppendArg("-o");
+  cmd_line.AppendArg(rdwr);
+  cmd_line.AppendArgPath(real_device_path);
+
+  // Launch the process.
+  base::ProcessHandle process_handle;
+  if (!base::LaunchProcess(cmd_line, options, &process_handle)) {
+    LOG(ERROR) << "Failed to launch authopen process.";
+    // TODO: close stuff.

[Robert Sesek, 2014/06/12 22:01:34]

This seems like a rather important TODO.

[Drew Haven, 2014/06/12 22:55:10]

ha, oops.  I did it by making sure everything was scoped and allocated to local
variables.  I just forgot to go back and remove the TODO.

+    return false;
+  }
+
+  // Receive a file descriptor from authopen using sndmsg and the SCM_RIGHTS
+  // extension.  |IPC::Channel| is built around |IPC::Listener|s, and it's

[Robert Sesek, 2014/06/12 22:01:35]

Well, that and the man page for `authopen` explicitly says to use sendmsg() with
-stdoutpipe.

[Drew Haven, 2014/06/12 22:55:10]

Done.

+  // simpler to
+  // just process one message off the socket.
+  int fd = -1;
+  msghdr message = {0};
+  const size_t kDataBufferSize = 1024;
+  char dataBuffer[kDataBufferSize];

[Robert Sesek, 2014/06/12 22:01:35]

Naming: use under_scores throughout this function.

[Drew Haven, 2014/06/12 22:55:10]

Whoops, copy-paste.

+  iovec ioVec[1];
+  ioVec[0].iov_base = dataBuffer;
+  ioVec[0].iov_len = kDataBufferSize;
+  message.msg_iov = ioVec;
+  message.msg_iovlen = 1;

[Robert Sesek, 2014/06/12 22:01:35]

sizeof(ioVec)

[Drew Haven, 2014/06/12 22:55:10]

Done.

+  const socklen_t kCmsgSocketSize = (socklen_t)CMSG_SPACE(sizeof(int));

[Robert Sesek, 2014/06/12 22:01:34]

C style casts are banned, and below.

[Drew Haven, 2014/06/12 22:55:10]

Done.

+  char cmsgSocket[kCmsgSocketSize];
+  message.msg_control = cmsgSocket;
+  message.msg_controllen = kCmsgSocketSize;
+  ssize_t size =
+      HANDLE_EINTR(recvmsg(parent_socket.get(), &message, 0));
+  if (size > 0) {
+    cmsghdr* cmsgSocketHeader = CMSG_FIRSTHDR(&message);
+
+    if (cmsgSocketHeader && cmsgSocketHeader->cmsg_level == SOL_SOCKET &&
+        cmsgSocketHeader->cmsg_type == SCM_RIGHTS)
+      fd = *((int*)CMSG_DATA(cmsgSocketHeader));
+  }
+
+  device_file_ = base::File(fd);
+
+  // Wait for the child.
+  int child_exit_status;
+  if (!base::WaitForExitCode(process_handle, &child_exit_status)) {
+    LOG(ERROR) << "Unable to wait for child.";
+    return false;
+  }
+
+  if (child_exit_status) {
+    LOG(ERROR) << "Child process returned failure.";
+    return false;
+  }
+
+  return device_file_.IsValid();
+}
+
+}  // namespace image_writer