| // 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 <IOKit/storage/IOStorageProtocolCharacteristics.h> |
| #include <sys/socket.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"; |
| |
| 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) { |
| PLOG(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::CommandLine(base::FilePath(kAuthOpenPath)); |
| 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."; |
| return false; |
| } |
| |
| // Receive a file descriptor from authopen which sends a single FD via |
| // sendmsg and the SCM_RIGHTS extension. |
| int fd = -1; |
| const size_t kDataBufferSize = sizeof(struct cmsghdr) + sizeof(int); |
| char data_buffer[kDataBufferSize]; |
| |
| struct iovec io_vec[1]; |
| io_vec[0].iov_base = data_buffer; |
| io_vec[0].iov_len = kDataBufferSize; |
| |
| const socklen_t kCmsgSocketSize = |
| static_cast<socklen_t>(CMSG_SPACE(sizeof(int))); |
| char cmsg_socket[kCmsgSocketSize]; |
| |
| struct msghdr message = {0}; |
| message.msg_iov = io_vec; |
| message.msg_iovlen = 1; |
| message.msg_control = cmsg_socket; |
| message.msg_controllen = kCmsgSocketSize; |
| |
| ssize_t size = HANDLE_EINTR(recvmsg(parent_socket.get(), &message, 0)); |
| if (size > 0) { |
| struct cmsghdr* cmsg_socket_header = CMSG_FIRSTHDR(&message); |
| |
| if (cmsg_socket_header && cmsg_socket_header->cmsg_level == SOL_SOCKET && |
| cmsg_socket_header->cmsg_type == SCM_RIGHTS) { |
| fd = *reinterpret_cast<int*>(CMSG_DATA(cmsg_socket_header)); |
| } |
| } |
| |
| 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 |