chrome/utility/image_writer/image_writer_handler.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/files/file_path.h"
   6 #include "chrome/common/chrome_utility_messages.h"
   7 #include "chrome/utility/image_writer/error_messages.h"
   8 #include "chrome/utility/image_writer/image_writer_handler.h"
   9 #include "content/public/utility/utility_thread.h"
  10
  11 #if defined(OS_WIN)
  12 #include <windows.h>
  13 #include <setupapi.h>
  14 #include <winioctl.h>
  15 #endif
  16
  17 namespace image_writer {
  18
  19 #if defined(OS_WIN)
  20 const size_t kStorageQueryBufferSize = 1024;
  21 #endif
  22
  23 ImageWriterHandler::ImageWriterHandler() : image_writer_(this) {}
  24 ImageWriterHandler::~ImageWriterHandler() {}
  25
  26 void ImageWriterHandler::SendSucceeded() {
  27   Send(new ChromeUtilityHostMsg_ImageWriter_Succeeded());
  28   content::UtilityThread::Get()->ReleaseProcessIfNeeded();
  29 }
  30
  31 void ImageWriterHandler::SendCancelled() {
  32   Send(new ChromeUtilityHostMsg_ImageWriter_Cancelled());
  33   content::UtilityThread::Get()->ReleaseProcessIfNeeded();
  34 }
  35
  36 void ImageWriterHandler::SendFailed(const std::string& message) {
  37   Send(new ChromeUtilityHostMsg_ImageWriter_Failed(message));
  38   content::UtilityThread::Get()->ReleaseProcessIfNeeded();
  39 }
  40
  41 void ImageWriterHandler::SendProgress(int64 progress) {
  42   Send(new ChromeUtilityHostMsg_ImageWriter_Progress(progress));
  43 }
  44
  45 void ImageWriterHandler::Send(IPC::Message* msg) {
  46   content::UtilityThread::Get()->Send(msg);
  47 }
  48
  49 bool ImageWriterHandler::OnMessageReceived(const IPC::Message& message) {
  50   bool handled = true;
  51   IPC_BEGIN_MESSAGE_MAP(ImageWriterHandler, message)
  52   IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ImageWriter_Write, OnWriteStart)
  53   IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ImageWriter_Verify, OnVerifyStart)
  54   IPC_MESSAGE_HANDLER(ChromeUtilityMsg_ImageWriter_Cancel, OnCancel)
  55   IPC_MESSAGE_UNHANDLED(handled = false)
  56   IPC_END_MESSAGE_MAP()
  57   return handled;
  58 }
  59
  60 void ImageWriterHandler::OnWriteStart(const base::FilePath& image,
  61                                       const base::FilePath& device) {
  62   if (!IsValidDevice(device)) {
  63     Send(new ChromeUtilityHostMsg_ImageWriter_Failed(error::kInvalidDevice));
  64     return;
  65   }
  66
  67   if (image_writer_.IsRunning()) {
  68     Send(new ChromeUtilityHostMsg_ImageWriter_Failed(
  69         error::kOperationAlreadyInProgress));
  70     return;
  71   }
  72   image_writer_.Write(image, device);
  73 }
  74
  75 void ImageWriterHandler::OnVerifyStart(const base::FilePath& image,
  76                                        const base::FilePath& device) {
  77   if (!IsValidDevice(device)) {
  78     Send(new ChromeUtilityHostMsg_ImageWriter_Failed(error::kInvalidDevice));
  79     return;
  80   }
  81
  82   if (image_writer_.IsRunning()) {
  83     Send(new ChromeUtilityHostMsg_ImageWriter_Failed(
  84         error::kOperationAlreadyInProgress));
  85     return;
  86   }
  87   image_writer_.Verify(image, device);
  88 }
  89
  90 void ImageWriterHandler::OnCancel() {
  91   if (image_writer_.IsRunning()) {
  92     image_writer_.Cancel();
  93   } else {
  94     SendCancelled();
  95   }
  96 }
  97
  98 bool ImageWriterHandler::IsValidDevice(const base::FilePath& device) {
  99 #if defined(OS_WIN)
 100   base::win::ScopedHandle device_handle(
 101       CreateFile(device.value().c_str(),
 102                  // Desired access, which is none as we only need metadata.
 103                  0,
 104                  // Required to be read + write for devices.
 105                  FILE_SHARE_READ | FILE_SHARE_WRITE,
 106                  NULL,           // Optional security attributes.
 107                  OPEN_EXISTING,  // Devices already exist.
 108                  0,              // No optional flags.
 109                  NULL));         // No template file.
 110
 111   if (!device_handle) {
 112     PLOG(ERROR) << "Opening device handle failed.";
 113     return false;
 114   }
 115
 116   STORAGE_PROPERTY_QUERY query = STORAGE_PROPERTY_QUERY();
 117   query.PropertyId = StorageDeviceProperty;
 118   query.QueryType = PropertyStandardQuery;
 119   DWORD bytes_returned;
 120
 121   scoped_ptr<char[]> output_buf(new char[kStorageQueryBufferSize]);
 122   BOOL status = DeviceIoControl(
 123       device_handle,                   // Device handle.
 124       IOCTL_STORAGE_QUERY_PROPERTY,    // Flag to request device properties.
 125       &query,                          // Query parameters.
 126       sizeof(STORAGE_PROPERTY_QUERY),  // query parameters size.
 127       output_buf.get(),                // output buffer.
 128       kStorageQueryBufferSize,         // Size of buffer.
 129       &bytes_returned,                 // Number of bytes returned.
 130                                        // Must not be null.
 131       NULL);                           // Optional unused overlapped perameter.
 132
 133   if (status == FALSE) {
 134     PLOG(ERROR) << "Storage property query failed.";
 135     return false;
 136   }
 137
 138   STORAGE_DEVICE_DESCRIPTOR* device_descriptor =
 139       reinterpret_cast<STORAGE_DEVICE_DESCRIPTOR*>(output_buf.get());
 140
 141   if (device_descriptor->RemovableMedia)
 142     return true;
 143
 144 #else
 145   // Other platforms will have to be added as they are supported.
 146   NOTIMPLEMENTED();
 147 #endif
 148   return false;
 149 }
 150
 151 }  // namespace image_writer