The Tor Browser: dom/bluetooth/bluedroid/BluetoothOppManager.cpp@b8a032363ba2 (annotated)

dom/bluetooth/bluedroid/BluetoothOppManager.cpp@b8a032363ba2 (annotated)

dom/bluetooth/bluedroid/BluetoothOppManager.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 40 -*- */
 /* vim: set ts=2 et sw=2 tw=80: */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
  * You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "base/basictypes.h"
 #include "BluetoothOppManager.h"
 #include "BluetoothService.h"
 #include "BluetoothSocket.h"
 #include "BluetoothUtils.h"
 #include "BluetoothUuid.h"
 #include "ObexBase.h"
 #include "mozilla/dom/bluetooth/BluetoothTypes.h"
 #include "mozilla/RefPtr.h"
 #include "mozilla/Services.h"
 #include "mozilla/StaticPtr.h"
 #include "nsAutoPtr.h"
 #include "nsCExternalHandlerService.h"
 #include "nsIObserver.h"
 #include "nsIObserverService.h"
 #include "nsIDOMFile.h"
 #include "nsIFile.h"
 #include "nsIInputStream.h"
 #include "nsIMIMEService.h"
 #include "nsIOutputStream.h"
 #include "nsIVolumeService.h"
 #include "nsNetUtil.h"
 #include "nsServiceManagerUtils.h"
 #define TARGET_SUBDIR "Download/Bluetooth/"
 USING_BLUETOOTH_NAMESPACE
 using namespace mozilla;
 using namespace mozilla::ipc;
 namespace {
 // Sending system message "bluetooth-opp-update-progress" every 50kb
 static const uint32_t kUpdateProgressBase = 50 * 1024;
 /*
  * The format of the header of an PUT request is
  * [opcode:1][packet length:2][headerId:1][header length:2]
  */
 static const uint32_t kPutRequestHeaderSize = 6;
 /*
  * The format of the appended header of an PUT request is
  * [headerId:1][header length:4]
  * P.S. Length of name header is 4 since unicode is 2 bytes per char.
  */
 static const uint32_t kPutRequestAppendHeaderSize = 5;
 StaticRefPtr<BluetoothOppManager> sBluetoothOppManager;
 static bool sInShutdown = false;
 }
 class mozilla::dom::bluetooth::SendFileBatch {
 public:
   SendFileBatch(const nsAString& aDeviceAddress, nsIDOMBlob* aBlob)
     : mDeviceAddress(aDeviceAddress)
   {
     mBlobs.AppendElement(aBlob);
   }
   nsString mDeviceAddress;
   nsCOMArray<nsIDOMBlob> mBlobs;
 };
 NS_IMETHODIMP
 BluetoothOppManager::Observe(nsISupports* aSubject,
                              const char* aTopic,
                              const char16_t* aData)
 {
   MOZ_ASSERT(sBluetoothOppManager);
   if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {
     HandleShutdown();
     return NS_OK;
   }
   MOZ_ASSERT(false, "BluetoothOppManager got unexpected topic!");
   return NS_ERROR_UNEXPECTED;
 }
 class SendSocketDataTask : public nsRunnable
 {
 public:
   SendSocketDataTask(uint8_t* aStream, uint32_t aSize)
     : mStream(aStream)
     , mSize(aSize)
   {
     MOZ_ASSERT(!NS_IsMainThread());
   }
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(NS_IsMainThread());
     sBluetoothOppManager->SendPutRequest(mStream, mSize);
     return NS_OK;
   }
 private:
   nsAutoArrayPtr<uint8_t> mStream;
   uint32_t mSize;
 };
 class ReadFileTask : public nsRunnable
 {
 public:
   ReadFileTask(nsIInputStream* aInputStream,
                uint32_t aRemoteMaxPacketSize) : mInputStream(aInputStream)
   {
     MOZ_ASSERT(NS_IsMainThread());
     mAvailablePacketSize = aRemoteMaxPacketSize - kPutRequestHeaderSize;
   }
   NS_IMETHOD Run()
   {
     MOZ_ASSERT(!NS_IsMainThread());
     uint32_t numRead;
     nsAutoArrayPtr<char> buf(new char[mAvailablePacketSize]);
     // function inputstream->Read() only works on non-main thread
     nsresult rv = mInputStream->Read(buf, mAvailablePacketSize, &numRead);
     if (NS_FAILED(rv)) {
       // Needs error handling here
       BT_WARNING("Failed to read from input stream");
       return NS_ERROR_FAILURE;
     }
     if (numRead > 0) {
       sBluetoothOppManager->CheckPutFinal(numRead);
       nsRefPtr<SendSocketDataTask> task =
         new SendSocketDataTask((uint8_t*)buf.forget(), numRead);
       if (NS_FAILED(NS_DispatchToMainThread(task))) {
         BT_WARNING("Failed to dispatch to main thread!");
         return NS_ERROR_FAILURE;
       }
     }
     return NS_OK;
   };
 private:
   nsCOMPtr<nsIInputStream> mInputStream;
   uint32_t mAvailablePacketSize;
 };
 class CloseSocketTask : public Task
 {
 public:
   CloseSocketTask(BluetoothSocket* aSocket) : mSocket(aSocket)
   {
     MOZ_ASSERT(aSocket);
   }
   void Run() MOZ_OVERRIDE
   {
     MOZ_ASSERT(NS_IsMainThread());
     mSocket->CloseDroidSocket();
   }
 private:
   nsRefPtr<BluetoothSocket> mSocket;
 };
 BluetoothOppManager::BluetoothOppManager() : mConnected(false)
                                            , mRemoteObexVersion(0)
                                            , mRemoteConnectionFlags(0)
                                            , mRemoteMaxPacketLength(0)
                                            , mLastCommand(0)
                                            , mPacketLength(0)
                                            , mPutPacketReceivedLength(0)
                                            , mBodySegmentLength(0)
                                            , mAbortFlag(false)
                                            , mNewFileFlag(false)
                                            , mPutFinalFlag(false)
                                            , mSendTransferCompleteFlag(false)
                                            , mSuccessFlag(false)
                                            , mIsServer(true)
                                            , mWaitingForConfirmationFlag(false)
                                            , mFileLength(0)
                                            , mSentFileLength(0)
                                            , mWaitingToSendPutFinal(false)
                                            , mCurrentBlobIndex(-1)
 {
   mDeviceAddress.AssignLiteral(BLUETOOTH_ADDRESS_NONE);
 }
 BluetoothOppManager::~BluetoothOppManager()
 {
   nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
   NS_ENSURE_TRUE_VOID(obs);
   if (NS_FAILED(obs->RemoveObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID))) {
     BT_WARNING("Failed to remove shutdown observer!");
   }
 }
 bool
 BluetoothOppManager::Init()
 {
   nsCOMPtr<nsIObserverService> obs = services::GetObserverService();
   NS_ENSURE_TRUE(obs, false);
   if (NS_FAILED(obs->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false))) {
     BT_WARNING("Failed to add shutdown observer!");
     return false;
   }
   /**
    * We don't start listening here as BluetoothServiceBluedroid calls Listen()
    * immediately when BT stops.
    *
    * If we start listening here, the listening fails when device boots up since
    * Listen() is called again and restarts server socket. The restart causes
    * absence of read events when device boots up.
    */
   return true;
 }
 //static
 BluetoothOppManager*
 BluetoothOppManager::Get()
 {
   MOZ_ASSERT(NS_IsMainThread());
   // If sBluetoothOppManager already exists, exit early
   if (sBluetoothOppManager) {
     return sBluetoothOppManager;
   }
   // If we're in shutdown, don't create a new instance
   NS_ENSURE_FALSE(sInShutdown, nullptr);
   // Create a new instance, register, and return
   BluetoothOppManager *manager = new BluetoothOppManager();
   NS_ENSURE_TRUE(manager->Init(), nullptr);
   sBluetoothOppManager = manager;
   return sBluetoothOppManager;
 }
 void
 BluetoothOppManager::ConnectInternal(const nsAString& aDeviceAddress)
 {
   MOZ_ASSERT(NS_IsMainThread());
   // Stop listening because currently we only support one connection at a time.
   if (mServerSocket) {
     mServerSocket->Disconnect();
     mServerSocket = nullptr;
   }
   mIsServer = false;
   BluetoothService* bs = BluetoothService::Get();
   if (!bs || sInShutdown || mSocket) {
     OnSocketConnectError(mSocket);
     return;
   }
   mSocket =
     new BluetoothSocket(this, BluetoothSocketType::RFCOMM, false, true);
   mSocket->Connect(aDeviceAddress, -1);
 }
 void
 BluetoothOppManager::HandleShutdown()
 {
   MOZ_ASSERT(NS_IsMainThread());
   sInShutdown = true;
   Disconnect(nullptr);
   sBluetoothOppManager = nullptr;
 }
 bool
 BluetoothOppManager::Listen()
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (mSocket) {
     BT_WARNING("mSocket exists. Failed to listen.");
     return false;
   }
   /**
    * Restart server socket since its underlying fd becomes invalid when
    * BT stops; otherwise no more read events would be received even if
    * BT restarts.
    */
   if (mServerSocket) {
     mServerSocket->Disconnect();
     mServerSocket = nullptr;
   }
   mServerSocket =
     new BluetoothSocket(this, BluetoothSocketType::RFCOMM, false, true);
   if (!mServerSocket->Listen(BluetoothReservedChannels::CHANNEL_OPUSH)) {
     BT_WARNING("[OPP] Can't listen on RFCOMM socket!");
     mServerSocket = nullptr;
     return false;
   }
   mIsServer = true;
   return true;
 }
 void
 BluetoothOppManager::StartSendingNextFile()
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!IsConnected());
   MOZ_ASSERT(!mBatches.IsEmpty());
   MOZ_ASSERT((int)mBatches[0].mBlobs.Length() > mCurrentBlobIndex + 1);
   mBlob = mBatches[0].mBlobs[++mCurrentBlobIndex];
   // Before sending content, we have to send a header including
   // information such as file name, file length and content type.
   ExtractBlobHeaders();
   StartFileTransfer();
   if (mCurrentBlobIndex == 0) {
     // We may have more than one file waiting for transferring, but only one
     // CONNECT request would be sent. Therefore check if this is the very first
     // file at the head of queue.
     SendConnectRequest();
   } else {
     SendPutHeaderRequest(mFileName, mFileLength);
     AfterFirstPut();
   }
 }
 bool
 BluetoothOppManager::SendFile(const nsAString& aDeviceAddress,
                               BlobParent* aActor)
 {
   MOZ_ASSERT(NS_IsMainThread());
   nsCOMPtr<nsIDOMBlob> blob = aActor->GetBlob();
   return SendFile(aDeviceAddress, blob.get());
 }
 bool
 BluetoothOppManager::SendFile(const nsAString& aDeviceAddress,
                               nsIDOMBlob* aBlob)
 {
   MOZ_ASSERT(NS_IsMainThread());
   AppendBlobToSend(aDeviceAddress, aBlob);
   if (!mSocket) {
     ProcessNextBatch();
   }
   return true;
 }
 void
 BluetoothOppManager::AppendBlobToSend(const nsAString& aDeviceAddress,
                                       nsIDOMBlob* aBlob)
 {
   MOZ_ASSERT(NS_IsMainThread());
   int indexTail = mBatches.Length() - 1;
   /**
    * Create a new batch if
    * - mBatches is empty, or
    * - aDeviceAddress differs from mDeviceAddress of the last batch
    */
   if (mBatches.IsEmpty() ||
       aDeviceAddress != mBatches[indexTail].mDeviceAddress) {
     SendFileBatch batch(aDeviceAddress, aBlob);
     mBatches.AppendElement(batch);
   } else {
     mBatches[indexTail].mBlobs.AppendElement(aBlob);
   }
 }
 void
 BluetoothOppManager::DiscardBlobsToSend()
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!mBatches.IsEmpty());
   MOZ_ASSERT(!mIsServer);
   int length = (int) mBatches[0].mBlobs.Length();
   while (length > mCurrentBlobIndex + 1) {
     mBlob = mBatches[0].mBlobs[++mCurrentBlobIndex];
     BT_LOGR("idx %d", mCurrentBlobIndex);
     ExtractBlobHeaders();
     StartFileTransfer();
     FileTransferComplete();
   }
 }
 bool
 BluetoothOppManager::ProcessNextBatch()
 {
   MOZ_ASSERT(NS_IsMainThread());
   // Remove the processed batch.
   // A batch is processed if we've incremented mCurrentBlobIndex for it.
   if (mCurrentBlobIndex >= 0) {
     ClearQueue();
     mBatches.RemoveElementAt(0);
     BT_LOGR("REMOVE. %d remaining", mBatches.Length());
   }
   // Process the next batch
   if (!mBatches.IsEmpty()) {
     ConnectInternal(mBatches[0].mDeviceAddress);
     return true;
   }
   // No more batch to process
   return false;
 }
 void
 BluetoothOppManager::ClearQueue()
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(!mIsServer);
   MOZ_ASSERT(!mBatches.IsEmpty());
   MOZ_ASSERT(!mBatches[0].mBlobs.IsEmpty());
   mCurrentBlobIndex = -1;
   mBlob = nullptr;
   mBatches[0].mBlobs.Clear();
 }
 bool
 BluetoothOppManager::StopSendingFile()
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (mIsServer) {
     mAbortFlag = true;
   } else {
     Disconnect(nullptr);
   }
   return true;
 }
 bool
 BluetoothOppManager::ConfirmReceivingFile(bool aConfirm)
 {
   NS_ENSURE_TRUE(mConnected, false);
   NS_ENSURE_TRUE(mWaitingForConfirmationFlag, false);
   mWaitingForConfirmationFlag = false;
   // For the first packet of first file
   bool success = false;
   if (aConfirm) {
     StartFileTransfer();
     if (CreateFile()) {
       success = WriteToFile(mBodySegment.get(), mBodySegmentLength);
     }
   }
   if (success && mPutFinalFlag) {
     mSuccessFlag = true;
     FileTransferComplete();
     NotifyAboutFileChange();
   }
   ReplyToPut(mPutFinalFlag, success);
   return true;
 }
 void
 BluetoothOppManager::AfterFirstPut()
 {
   mUpdateProgressCounter = 1;
   mPutFinalFlag = false;
   mPutPacketReceivedLength = 0;
   mSentFileLength = 0;
   mWaitingToSendPutFinal = false;
   mSuccessFlag = false;
   mBodySegmentLength = 0;
 }
 void
 BluetoothOppManager::AfterOppConnected()
 {
   MOZ_ASSERT(NS_IsMainThread());
   mConnected = true;
   mAbortFlag = false;
   mWaitingForConfirmationFlag = true;
   AfterFirstPut();
   // Get a mount lock to prevent the sdcard from being shared with
   // the PC while we're doing a OPP file transfer. After OPP transaction
   // were done, the mount lock will be freed.
   if (!AcquireSdcardMountLock()) {
     // If we fail to get a mount lock, abort this transaction
     // Directly sending disconnect-request is better than abort-request
     BT_WARNING("BluetoothOPPManager couldn't get a mount lock!");
     Disconnect(nullptr);
   }
 }
 void
 BluetoothOppManager::AfterOppDisconnected()
 {
   MOZ_ASSERT(NS_IsMainThread());
   mConnected = false;
   mLastCommand = 0;
   mPutPacketReceivedLength = 0;
   mDsFile = nullptr;
   // We can't reset mSuccessFlag here since this function may be called
   // before we send system message of transfer complete
   // mSuccessFlag = false;
   if (mInputStream) {
     mInputStream->Close();
     mInputStream = nullptr;
   }
   if (mOutputStream) {
     mOutputStream->Close();
     mOutputStream = nullptr;
   }
   if (mReadFileThread) {
     mReadFileThread->Shutdown();
     mReadFileThread = nullptr;
   }
   // Release the Mount lock if file transfer completed
   if (mMountLock) {
     // The mount lock will be implicitly unlocked
     mMountLock = nullptr;
   }
 }
 void
 BluetoothOppManager::DeleteReceivedFile()
 {
   if (mOutputStream) {
     mOutputStream->Close();
     mOutputStream = nullptr;
   }
   if (mDsFile && mDsFile->mFile) {
     mDsFile->mFile->Remove(false);
     mDsFile = nullptr;
   }
 }
 bool
 BluetoothOppManager::CreateFile()
 {
   MOZ_ASSERT(mPutPacketReceivedLength == mPacketLength);
   nsString path;
   path.AssignLiteral(TARGET_SUBDIR);
   path.Append(mFileName);
   mDsFile = DeviceStorageFile::CreateUnique(
               path, nsIFile::NORMAL_FILE_TYPE, 0644);
   NS_ENSURE_TRUE(mDsFile, false);
   nsCOMPtr<nsIFile> f;
   mDsFile->mFile->Clone(getter_AddRefs(f));
   /*
    * The function CreateUnique() may create a file with a different file
    * name from the original mFileName. Therefore we have to retrieve
    * the file name again.
    */
   f->GetLeafName(mFileName);
   NS_NewLocalFileOutputStream(getter_AddRefs(mOutputStream), f);
   NS_ENSURE_TRUE(mOutputStream, false);
   return true;
 }
 bool
 BluetoothOppManager::WriteToFile(const uint8_t* aData, int aDataLength)
 {
   NS_ENSURE_TRUE(mOutputStream, false);
   uint32_t wrote = 0;
   mOutputStream->Write((const char*)aData, aDataLength, &wrote);
   NS_ENSURE_TRUE(aDataLength == (int) wrote, false);
   return true;
 }
 // Virtual function of class SocketConsumer
 void
 BluetoothOppManager::ExtractPacketHeaders(const ObexHeaderSet& aHeader)
 {
   if (aHeader.Has(ObexHeaderId::Name)) {
     aHeader.GetName(mFileName);
   }
   if (aHeader.Has(ObexHeaderId::Type)) {
     aHeader.GetContentType(mContentType);
   }
   if (aHeader.Has(ObexHeaderId::Length)) {
     aHeader.GetLength(&mFileLength);
   }
   if (aHeader.Has(ObexHeaderId::Body) ||
       aHeader.Has(ObexHeaderId::EndOfBody)) {
     uint8_t* bodyPtr;
     aHeader.GetBody(&bodyPtr);
     mBodySegment = bodyPtr;
     aHeader.GetBodyLength(&mBodySegmentLength);
   }
 }
 bool
 BluetoothOppManager::ExtractBlobHeaders()
 {
   RetrieveSentFileName();
   nsresult rv = mBlob->GetType(mContentType);
   if (NS_FAILED(rv)) {
     BT_WARNING("Can't get content type");
     SendDisconnectRequest();
     return false;
   }
   uint64_t fileLength;
   rv = mBlob->GetSize(&fileLength);
   if (NS_FAILED(rv)) {
     BT_WARNING("Can't get file size");
     SendDisconnectRequest();
     return false;
   }
   // Currently we keep the size of files which were sent/received via
   // Bluetooth not exceed UINT32_MAX because the Length header in OBEX
   // is only 4-byte long. Although it is possible to transfer a file
   // larger than UINT32_MAX, it needs to parse another OBEX Header
   // and I would like to leave it as a feature.
   if (fileLength > (uint64_t)UINT32_MAX) {
     BT_WARNING("The file size is too large for now");
     SendDisconnectRequest();
     return false;
   }
   mFileLength = fileLength;
   rv = NS_NewThread(getter_AddRefs(mReadFileThread));
   if (NS_FAILED(rv)) {
     BT_WARNING("Can't create thread");
     SendDisconnectRequest();
     return false;
   }
   return true;
 }
 void
 BluetoothOppManager::RetrieveSentFileName()
 {
   mFileName.Truncate();
   nsCOMPtr<nsIDOMFile> file = do_QueryInterface(mBlob);
   if (file) {
     file->GetName(mFileName);
   }
   /**
    * We try our best to get the file extention to avoid interoperability issues.
    * However, once we found that we are unable to get suitable extension or
    * information about the content type, sending a pre-defined file name without
    * extension would be fine.
    */
   if (mFileName.IsEmpty()) {
     mFileName.AssignLiteral("Unknown");
   }
   int32_t offset = mFileName.RFindChar('/');
   if (offset != kNotFound) {
     mFileName = Substring(mFileName, offset + 1);
   }
   offset = mFileName.RFindChar('.');
   if (offset == kNotFound) {
     nsCOMPtr<nsIMIMEService> mimeSvc = do_GetService(NS_MIMESERVICE_CONTRACTID);
     if (mimeSvc) {
       nsString mimeType;
       mBlob->GetType(mimeType);
       nsCString extension;
       nsresult rv =
         mimeSvc->GetPrimaryExtension(NS_LossyConvertUTF16toASCII(mimeType),
                                      EmptyCString(),
                                      extension);
       if (NS_SUCCEEDED(rv)) {
         mFileName.AppendLiteral(".");
         AppendUTF8toUTF16(extension, mFileName);
       }
     }
   }
 }
 bool
 BluetoothOppManager::IsReservedChar(char16_t c)
 {
   return (c < 0x0020 ||
           c == char16_t('?') || c == char16_t('|') || c == char16_t('<') ||
           c == char16_t('>') || c == char16_t('"') || c == char16_t(':') ||
           c == char16_t('/') || c == char16_t('*') || c == char16_t('\\'));
 }
 void
 BluetoothOppManager::ValidateFileName()
 {
   int length = mFileName.Length();
   for (int i = 0; i < length; ++i) {
     // Replace reserved char of fat file system with '_'
     if (IsReservedChar(mFileName.CharAt(i))) {
       mFileName.Replace(i, 1, char16_t('_'));
     }
   }
 }
 bool
 BluetoothOppManager::ComposePacket(uint8_t aOpCode, UnixSocketRawData* aMessage)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aMessage);
   int frameHeaderLength = 0;
   // See if this is the first part of each Put packet
   if (mPutPacketReceivedLength == 0) {
     // Section 3.3.3 "Put", IrOBEX 1.2
     // [opcode:1][length:2][Headers:var]
     frameHeaderLength = 3;
     mPacketLength = ((((int)aMessage->mData[1]) << 8) | aMessage->mData[2]) -
                       frameHeaderLength;
     /**
      * A PUT request from remote devices may be divided into multiple parts.
      * In other words, one request may need to be received multiple times,
      * so here we keep a variable mPutPacketReceivedLength to indicate if
      * current PUT request is done.
      */
     mReceivedDataBuffer = new uint8_t[mPacketLength];
     mPutFinalFlag = (aOpCode == ObexRequestCode::PutFinal);
   }
   int dataLength = aMessage->mSize - frameHeaderLength;
   // Check length before memcpy to prevent from memory pollution
   if (dataLength < 0 ||
       mPutPacketReceivedLength + dataLength > mPacketLength) {
     BT_LOGR("Received packet size is unreasonable");
     ReplyToPut(mPutFinalFlag, false);
     DeleteReceivedFile();
     FileTransferComplete();
     return false;
   }
   memcpy(mReceivedDataBuffer.get() + mPutPacketReceivedLength,
          &aMessage->mData[frameHeaderLength], dataLength);
   mPutPacketReceivedLength += dataLength;
   return (mPutPacketReceivedLength == mPacketLength);
 }
 void
 BluetoothOppManager::ServerDataHandler(UnixSocketRawData* aMessage)
 {
   MOZ_ASSERT(NS_IsMainThread());
   uint8_t opCode;
   int receivedLength = aMessage->mSize;
   if (mPutPacketReceivedLength > 0) {
     opCode = mPutFinalFlag ? ObexRequestCode::PutFinal : ObexRequestCode::Put;
   } else {
     opCode = aMessage->mData[0];
     // When there's a Put packet right after a PutFinal packet,
     // which means it's the start point of a new file.
     if (mPutFinalFlag &&
         (opCode == ObexRequestCode::Put ||
          opCode == ObexRequestCode::PutFinal)) {
       mNewFileFlag = true;
       AfterFirstPut();
     }
   }
   ObexHeaderSet pktHeaders(opCode);
   if (opCode == ObexRequestCode::Connect) {
     // Section 3.3.1 "Connect", IrOBEX 1.2
     // [opcode:1][length:2][version:1][flags:1][MaxPktSizeWeCanReceive:2]
     // [Headers:var]
     if (!ParseHeaders(&aMessage->mData[7], receivedLength - 7, &pktHeaders)) {
       ReplyError(ObexResponseCode::BadRequest);
       return;
     }
     ReplyToConnect();
     AfterOppConnected();
   } else if (opCode == ObexRequestCode::Abort) {
     // Section 3.3.5 "Abort", IrOBEX 1.2
     // [opcode:1][length:2][Headers:var]
     if (!ParseHeaders(&aMessage->mData[3], receivedLength - 3, &pktHeaders)) {
       ReplyError(ObexResponseCode::BadRequest);
       return;
     }
     ReplyToDisconnectOrAbort();
     DeleteReceivedFile();
   } else if (opCode == ObexRequestCode::Disconnect) {
     // Section 3.3.2 "Disconnect", IrOBEX 1.2
     // [opcode:1][length:2][Headers:var]
     if (!ParseHeaders(&aMessage->mData[3], receivedLength - 3, &pktHeaders)) {
       ReplyError(ObexResponseCode::BadRequest);
       return;
     }
     ReplyToDisconnectOrAbort();
     AfterOppDisconnected();
     FileTransferComplete();
   } else if (opCode == ObexRequestCode::Put ||
              opCode == ObexRequestCode::PutFinal) {
     if (!ComposePacket(opCode, aMessage)) {
       return;
     }
     // A Put packet is received completely
     ParseHeaders(mReceivedDataBuffer.get(),
                  mPutPacketReceivedLength, &pktHeaders);
     ExtractPacketHeaders(pktHeaders);
     ValidateFileName();
     // When we cancel the transfer, delete the file and notify completion
     if (mAbortFlag) {
       ReplyToPut(mPutFinalFlag, false);
       mSentFileLength += mBodySegmentLength;
       DeleteReceivedFile();
       FileTransferComplete();
       return;
     }
     // Wait until get confirmation from user, then create file and write to it
     if (mWaitingForConfirmationFlag) {
       ReceivingFileConfirmation();
       mSentFileLength += mBodySegmentLength;
       return;
     }
     // Already get confirmation from user, create a new file if needed and
     // write to output stream
     if (mNewFileFlag) {
       StartFileTransfer();
       if (!CreateFile()) {
         ReplyToPut(mPutFinalFlag, false);
         return;
       }
       mNewFileFlag = false;
     }
     if (!WriteToFile(mBodySegment.get(), mBodySegmentLength)) {
       ReplyToPut(mPutFinalFlag, false);
       return;
     }
     ReplyToPut(mPutFinalFlag, true);
     // Send progress update
     mSentFileLength += mBodySegmentLength;
     if (mSentFileLength > kUpdateProgressBase * mUpdateProgressCounter) {
       UpdateProgress();
       mUpdateProgressCounter = mSentFileLength / kUpdateProgressBase + 1;
     }
     // Success to receive a file and notify completion
     if (mPutFinalFlag) {
       mSuccessFlag = true;
       FileTransferComplete();
       NotifyAboutFileChange();
     }
   } else if (opCode == ObexRequestCode::Get ||
              opCode == ObexRequestCode::GetFinal ||
              opCode == ObexRequestCode::SetPath) {
     ReplyError(ObexResponseCode::BadRequest);
     BT_WARNING("Unsupported ObexRequestCode");
   } else {
     ReplyError(ObexResponseCode::NotImplemented);
     BT_WARNING("Unrecognized ObexRequestCode");
   }
 }
 void
 BluetoothOppManager::ClientDataHandler(UnixSocketRawData* aMessage)
 {
   MOZ_ASSERT(NS_IsMainThread());
   uint8_t opCode = aMessage->mData[0];
   // Check response code and send out system message as finished if the response
   // code is somehow incorrect.
   uint8_t expectedOpCode = ObexResponseCode::Success;
   if (mLastCommand == ObexRequestCode::Put) {
     expectedOpCode = ObexResponseCode::Continue;
   }
   if (opCode != expectedOpCode) {
     if (mLastCommand == ObexRequestCode::Put ||
         mLastCommand == ObexRequestCode::Abort ||
         mLastCommand == ObexRequestCode::PutFinal) {
       SendDisconnectRequest();
     }
     nsAutoCString str;
     str += "[OPP] 0x";
     str.AppendInt(mLastCommand, 16);
     str += " failed";
     BT_WARNING(str.get());
     FileTransferComplete();
     return;
   }
   if (mLastCommand == ObexRequestCode::PutFinal) {
     mSuccessFlag = true;
     FileTransferComplete();
     if (mInputStream) {
       mInputStream->Close();
       mInputStream = nullptr;
     }
     if (mCurrentBlobIndex + 1 == (int) mBatches[0].mBlobs.Length()) {
       SendDisconnectRequest();
     } else {
       StartSendingNextFile();
     }
   } else if (mLastCommand == ObexRequestCode::Abort) {
     SendDisconnectRequest();
     FileTransferComplete();
   } else if (mLastCommand == ObexRequestCode::Disconnect) {
     AfterOppDisconnected();
     // Most devices will directly terminate connection after receiving
     // Disconnect request, so we make a delay here. If the socket hasn't been
     // disconnected, we will close it.
     if (mSocket) {
       MessageLoop::current()->
         PostDelayedTask(FROM_HERE, new CloseSocketTask(mSocket), 1000);
     }
   } else if (mLastCommand == ObexRequestCode::Connect) {
     MOZ_ASSERT(!mFileName.IsEmpty());
     MOZ_ASSERT(mBlob);
     AfterOppConnected();
     // Keep remote information
     mRemoteObexVersion = aMessage->mData[3];
     mRemoteConnectionFlags = aMessage->mData[4];
     mRemoteMaxPacketLength =
       (((int)(aMessage->mData[5]) << 8) | aMessage->mData[6]);
     // The length of file name exceeds maximum length.
     int fileNameByteLen = (mFileName.Length() + 1) * 2;
     int headerLen = kPutRequestHeaderSize + kPutRequestAppendHeaderSize;
     if (fileNameByteLen > mRemoteMaxPacketLength - headerLen) {
       BT_WARNING("The length of file name is aberrant.");
       SendDisconnectRequest();
       return;
     }
     SendPutHeaderRequest(mFileName, mFileLength);
   } else if (mLastCommand == ObexRequestCode::Put) {
     if (mWaitingToSendPutFinal) {
       SendPutFinalRequest();
       return;
     }
     if (kUpdateProgressBase * mUpdateProgressCounter < mSentFileLength) {
       UpdateProgress();
       mUpdateProgressCounter = mSentFileLength / kUpdateProgressBase + 1;
     }
     nsresult rv;
     if (!mInputStream) {
       rv = mBlob->GetInternalStream(getter_AddRefs(mInputStream));
       if (NS_FAILED(rv)) {
         BT_WARNING("Can't get internal stream of blob");
         SendDisconnectRequest();
         return;
       }
     }
     nsRefPtr<ReadFileTask> task = new ReadFileTask(mInputStream,
                                                    mRemoteMaxPacketLength);
     rv = mReadFileThread->Dispatch(task, NS_DISPATCH_NORMAL);
     if (NS_FAILED(rv)) {
       BT_WARNING("Cannot dispatch read file task!");
       SendDisconnectRequest();
     }
   } else {
     BT_WARNING("Unhandled ObexRequestCode");
   }
 }
 // Virtual function of class SocketConsumer
 void
 BluetoothOppManager::ReceiveSocketData(BluetoothSocket* aSocket,
                                        nsAutoPtr<UnixSocketRawData>& aMessage)
 {
   if (mIsServer) {
     ServerDataHandler(aMessage);
   } else {
     ClientDataHandler(aMessage);
   }
 }
 void
 BluetoothOppManager::SendConnectRequest()
 {
   if (mConnected) return;
   // Section 3.3.1 "Connect", IrOBEX 1.2
   // [opcode:1][length:2][version:1][flags:1][MaxPktSizeWeCanReceive:2]
   // [Headers:var]
   uint8_t req[255];
   int index = 7;
   req[3] = 0x10; // version=1.0
   req[4] = 0x00; // flag=0x00
   req[5] = BluetoothOppManager::MAX_PACKET_LENGTH >> 8;
   req[6] = (uint8_t)BluetoothOppManager::MAX_PACKET_LENGTH;
   SendObexData(req, ObexRequestCode::Connect, index);
 }
 void
 BluetoothOppManager::SendPutHeaderRequest(const nsAString& aFileName,
                                           int aFileSize)
 {
   if (!mConnected) return;
   uint8_t* req = new uint8_t[mRemoteMaxPacketLength];
   int len = aFileName.Length();
   uint8_t* fileName = new uint8_t[(len + 1) * 2];
   const char16_t* fileNamePtr = aFileName.BeginReading();
   for (int i = 0; i < len; i++) {
     fileName[i * 2] = (uint8_t)(fileNamePtr[i] >> 8);
     fileName[i * 2 + 1] = (uint8_t)fileNamePtr[i];
   }
   fileName[len * 2] = 0x00;
   fileName[len * 2 + 1] = 0x00;
   int index = 3;
   index += AppendHeaderName(&req[index], mRemoteMaxPacketLength - index,
                             (char*)fileName, (len + 1) * 2);
   index += AppendHeaderLength(&req[index], aFileSize);
   SendObexData(req, ObexRequestCode::Put, index);
   delete [] fileName;
   delete [] req;
 }
 void
 BluetoothOppManager::SendPutRequest(uint8_t* aFileBody,
                                     int aFileBodyLength)
 {
   if (!mConnected) return;
   int packetLeftSpace = mRemoteMaxPacketLength - kPutRequestHeaderSize;
   if (aFileBodyLength > packetLeftSpace) {
     BT_WARNING("Not allowed such a small MaxPacketLength value");
     return;
   }
   // Section 3.3.3 "Put", IrOBEX 1.2
   // [opcode:1][length:2][Headers:var]
   uint8_t* req = new uint8_t[mRemoteMaxPacketLength];
   int index = 3;
   index += AppendHeaderBody(&req[index], mRemoteMaxPacketLength - index,
                             aFileBody, aFileBodyLength);
   SendObexData(req, ObexRequestCode::Put, index);
   delete [] req;
   mSentFileLength += aFileBodyLength;
 }
 void
 BluetoothOppManager::SendPutFinalRequest()
 {
   if (!mConnected) return;
   /**
    * Section 2.2.9, "End-of-Body", IrObex 1.2
    * End-of-Body is used to identify the last chunk of the object body.
    * For most platforms, a PutFinal packet is sent with an zero length
    * End-of-Body header.
    */
   // [opcode:1][length:2]
   int index = 3;
   uint8_t* req = new uint8_t[mRemoteMaxPacketLength];
   index += AppendHeaderEndOfBody(&req[index]);
   SendObexData(req, ObexRequestCode::PutFinal, index);
   delete [] req;
   mWaitingToSendPutFinal = false;
 }
 void
 BluetoothOppManager::SendDisconnectRequest()
 {
   if (!mConnected) return;
   // Section 3.3.2 "Disconnect", IrOBEX 1.2
   // [opcode:1][length:2][Headers:var]
   uint8_t req[255];
   int index = 3;
   SendObexData(req, ObexRequestCode::Disconnect, index);
 }
 void
 BluetoothOppManager::CheckPutFinal(uint32_t aNumRead)
 {
   if (mSentFileLength + aNumRead >= mFileLength) {
     mWaitingToSendPutFinal = true;
   }
 }
 bool
 BluetoothOppManager::IsConnected()
 {
   return (mConnected && !mSendTransferCompleteFlag);
 }
 void
 BluetoothOppManager::GetAddress(nsAString& aDeviceAddress)
 {
   return mSocket->GetAddress(aDeviceAddress);
 }
 void
 BluetoothOppManager::ReplyToConnect()
 {
   if (mConnected) return;
   // Section 3.3.1 "Connect", IrOBEX 1.2
   // [opcode:1][length:2][version:1][flags:1][MaxPktSizeWeCanReceive:2]
   // [Headers:var]
   uint8_t req[255];
   int index = 7;
   req[3] = 0x10; // version=1.0
   req[4] = 0x00; // flag=0x00
   req[5] = BluetoothOppManager::MAX_PACKET_LENGTH >> 8;
   req[6] = (uint8_t)BluetoothOppManager::MAX_PACKET_LENGTH;
   SendObexData(req, ObexResponseCode::Success, index);
 }
 void
 BluetoothOppManager::ReplyToDisconnectOrAbort()
 {
   if (!mConnected) return;
   // Section 3.3.2 "Disconnect" and Section 3.3.5 "Abort", IrOBEX 1.2
   // The format of response packet of "Disconnect" and "Abort" are the same
   // [opcode:1][length:2][Headers:var]
   uint8_t req[255];
   int index = 3;
   SendObexData(req, ObexResponseCode::Success, index);
 }
 void
 BluetoothOppManager::ReplyToPut(bool aFinal, bool aContinue)
 {
   if (!mConnected) return;
   // The received length can be reset here because this is where we reply to a
   // complete put packet.
   mPutPacketReceivedLength = 0;
   // Section 3.3.2 "Disconnect", IrOBEX 1.2
   // [opcode:1][length:2][Headers:var]
   uint8_t req[255];
   int index = 3;
   uint8_t opcode;
   if (aContinue) {
     opcode = (aFinal)? ObexResponseCode::Success :
                        ObexResponseCode::Continue;
   } else {
     opcode = (aFinal)? ObexResponseCode::Unauthorized :
                        ObexResponseCode::Unauthorized & (~FINAL_BIT);
   }
   SendObexData(req, opcode, index);
 }
 void
 BluetoothOppManager::ReplyError(uint8_t aError)
 {
   BT_LOGR("error: %d", aError);
   // Section 3.2 "Response Format", IrOBEX 1.2
   // [opcode:1][length:2][Headers:var]
   uint8_t req[255];
   int index = 3;
   SendObexData(req, aError, index);
 }
 void
 BluetoothOppManager::SendObexData(uint8_t* aData, uint8_t aOpcode, int aSize)
 {
   SetObexPacketInfo(aData, aOpcode, aSize);
   if (!mIsServer) {
     mLastCommand = aOpcode;
   }
   UnixSocketRawData* s = new UnixSocketRawData(aSize);
   memcpy(s->mData, aData, s->mSize);
   mSocket->SendDroidSocketData(s);
 }
 void
 BluetoothOppManager::FileTransferComplete()
 {
   if (mSendTransferCompleteFlag) {
     return;
   }
   NS_NAMED_LITERAL_STRING(type, "bluetooth-opp-transfer-complete");
   InfallibleTArray<BluetoothNamedValue> parameters;
   BT_APPEND_NAMED_VALUE(parameters, "address", mDeviceAddress);
   BT_APPEND_NAMED_VALUE(parameters, "success", mSuccessFlag);
   BT_APPEND_NAMED_VALUE(parameters, "received", mIsServer);
   BT_APPEND_NAMED_VALUE(parameters, "fileName", mFileName);
   BT_APPEND_NAMED_VALUE(parameters, "fileLength", mSentFileLength);
   BT_APPEND_NAMED_VALUE(parameters, "contentType", mContentType);
   BT_ENSURE_TRUE_VOID_BROADCAST_SYSMSG(type, parameters);
   mSendTransferCompleteFlag = true;
 }
 void
 BluetoothOppManager::StartFileTransfer()
 {
   NS_NAMED_LITERAL_STRING(type, "bluetooth-opp-transfer-start");
   InfallibleTArray<BluetoothNamedValue> parameters;
   BT_APPEND_NAMED_VALUE(parameters, "address", mDeviceAddress);
   BT_APPEND_NAMED_VALUE(parameters, "received", mIsServer);
   BT_APPEND_NAMED_VALUE(parameters, "fileName", mFileName);
   BT_APPEND_NAMED_VALUE(parameters, "fileLength", mFileLength);
   BT_APPEND_NAMED_VALUE(parameters, "contentType", mContentType);
   BT_ENSURE_TRUE_VOID_BROADCAST_SYSMSG(type, parameters);
   mSendTransferCompleteFlag = false;
 }
 void
 BluetoothOppManager::UpdateProgress()
 {
   NS_NAMED_LITERAL_STRING(type, "bluetooth-opp-update-progress");
   InfallibleTArray<BluetoothNamedValue> parameters;
   BT_APPEND_NAMED_VALUE(parameters, "address", mDeviceAddress);
   BT_APPEND_NAMED_VALUE(parameters, "received", mIsServer);
   BT_APPEND_NAMED_VALUE(parameters, "processedLength", mSentFileLength);
   BT_APPEND_NAMED_VALUE(parameters, "fileLength", mFileLength);
   BT_ENSURE_TRUE_VOID_BROADCAST_SYSMSG(type, parameters);
 }
 void
 BluetoothOppManager::ReceivingFileConfirmation()
 {
   NS_NAMED_LITERAL_STRING(type, "bluetooth-opp-receiving-file-confirmation");
   InfallibleTArray<BluetoothNamedValue> parameters;
   BT_APPEND_NAMED_VALUE(parameters, "address", mDeviceAddress);
   BT_APPEND_NAMED_VALUE(parameters, "fileName", mFileName);
   BT_APPEND_NAMED_VALUE(parameters, "fileLength", mFileLength);
   BT_APPEND_NAMED_VALUE(parameters, "contentType", mContentType);
   BT_ENSURE_TRUE_VOID_BROADCAST_SYSMSG(type, parameters);
 }
 void
 BluetoothOppManager::NotifyAboutFileChange()
 {
   NS_NAMED_LITERAL_STRING(data, "modified");
   nsCOMPtr<nsIObserverService> obs =
     mozilla::services::GetObserverService();
   NS_ENSURE_TRUE_VOID(obs);
   obs->NotifyObservers(mDsFile, "file-watcher-notify", data.get());
 }
 void
 BluetoothOppManager::OnSocketConnectSuccess(BluetoothSocket* aSocket)
 {
   BT_LOGR("[%s]", (mIsServer)? "server" : "client");
   MOZ_ASSERT(aSocket);
   /**
    * If the created connection is an inbound connection, close server socket
    * because currently only one file-transfer session is allowed. After that,
    * we need to make sure that server socket would be nulled out.
    * As for outbound connections, we just notify the controller that it's done.
    */
   if (aSocket == mServerSocket) {
     MOZ_ASSERT(!mSocket);
     mServerSocket.swap(mSocket);
   }
   // Cache device address since we can't get socket address when a remote
   // device disconnect with us.
   mSocket->GetAddress(mDeviceAddress);
   // Start sending file if we connect as a client
   if (!mIsServer) {
     StartSendingNextFile();
   }
 }
 void
 BluetoothOppManager::OnSocketConnectError(BluetoothSocket* aSocket)
 {
   BT_LOGR("[%s]", (mIsServer)? "server" : "client");
   mServerSocket = nullptr;
   mSocket = nullptr;
   if (!mIsServer) {
     // Inform gaia of remaining blobs' sending failure
     DiscardBlobsToSend();
   }
   // Listen as a server if there's no more batch to process
   if (!ProcessNextBatch()) {
     Listen();
   }
 }
 void
 BluetoothOppManager::OnSocketDisconnect(BluetoothSocket* aSocket)
 {
   MOZ_ASSERT(aSocket);
   if (aSocket != mSocket) {
     // Do nothing when a listening server socket is closed.
     return;
   }
   BT_LOGR("[%s]", (mIsServer) ? "server" : "client");
   /**
    * It is valid for a bluetooth device which is transfering file via OPP
    * closing socket without sending OBEX disconnect request first. So we
    * delete the broken file when we failed to receive a file from the remote,
    * and notify the transfer has been completed (but failed). We also call
    * AfterOppDisconnected here to ensure all variables will be cleaned.
    */
   if (!mSuccessFlag) {
     if (mIsServer) {
       DeleteReceivedFile();
     }
     FileTransferComplete();
     if (!mIsServer) {
       // Inform gaia of remaining blobs' sending failure
       DiscardBlobsToSend();
     }
   }
   AfterOppDisconnected();
   mDeviceAddress.AssignLiteral(BLUETOOTH_ADDRESS_NONE);
   mSuccessFlag = false;
   mSocket = nullptr;
   // Listen as a server if there's no more batch to process
   if (!ProcessNextBatch()) {
     Listen();
   }
 }
 void
 BluetoothOppManager::Disconnect(BluetoothProfileController* aController)
 {
   if (mSocket) {
     mSocket->Disconnect();
   } else {
     BT_WARNING("%s: No ongoing file transfer to stop", __FUNCTION__);
   }
 }
 NS_IMPL_ISUPPORTS(BluetoothOppManager, nsIObserver)
 bool
 BluetoothOppManager::AcquireSdcardMountLock()
 {
   nsCOMPtr<nsIVolumeService> volumeSrv =
     do_GetService(NS_VOLUMESERVICE_CONTRACTID);
   NS_ENSURE_TRUE(volumeSrv, false);
   nsresult rv;
   rv = volumeSrv->CreateMountLock(NS_LITERAL_STRING("sdcard"),
                                   getter_AddRefs(mMountLock));
   NS_ENSURE_SUCCESS(rv, false);
   return true;
 }
 void
 BluetoothOppManager::OnGetServiceChannel(const nsAString& aDeviceAddress,
                                          const nsAString& aServiceUuid,
                                          int aChannel)
 {
   MOZ_ASSERT(false);
 }
 void
 BluetoothOppManager::OnUpdateSdpRecords(const nsAString& aDeviceAddress)
 {
   MOZ_ASSERT(false);
 }
 void
 BluetoothOppManager::Connect(const nsAString& aDeviceAddress,
                              BluetoothProfileController* aController)
 {
   MOZ_ASSERT(false);
 }
 void
 BluetoothOppManager::OnConnect(const nsAString& aErrorStr)
 {
   MOZ_ASSERT(false);
 }
 void
 BluetoothOppManager::OnDisconnect(const nsAString& aErrorStr)
 {
   MOZ_ASSERT(false);
 }
 void
 BluetoothOppManager::Reset()
 {
   MOZ_ASSERT(false);
 }

The Tor Browser / annotate

dom/bluetooth/bluedroid/BluetoothOppManager.cpp@b8a032363ba2 (annotated)

dom/bluetooth/bluedroid/BluetoothOppManager.cpp