The Tor Browser: comparison dom/bluetooth/bluedroid/BluetoothSocket.cpp

--1:000000000000
+:1790d14430a4
+/* -*- 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 "BluetoothSocket.h"
+#include <hardware/bluetooth.h>
+#include <hardware/bt_sock.h>
+#include <sys/socket.h>
+#include "base/message_loop.h"
+#include "BluetoothSocketObserver.h"
+#include "BluetoothUtils.h"
+#include "mozilla/FileUtils.h"
+#include "mozilla/RefPtr.h"
+#include "nsThreadUtils.h"
+#include "nsXULAppAPI.h"
+#define FIRST_SOCKET_INFO_MSG_LENGTH 4
+#define TOTAL_SOCKET_INFO_LENGTH 20
+using namespace mozilla::ipc;
+USING_BLUETOOTH_NAMESPACE
+static const size_t MAX_READ_SIZE = 1 << 16;
+static const uint8_t UUID_OBEX_OBJECT_PUSH[] = {
+0x00, 0x00, 0x11, 0x05, 0x00, 0x00, 0x10, 0x00,
+0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB
+};
+static const btsock_interface_t* sBluetoothSocketInterface = nullptr;
+// helper functions
+static bool
+EnsureBluetoothSocketHalLoad()
+{
+if (sBluetoothSocketInterface) {
+return true;
+}
+const bt_interface_t* btInf = GetBluetoothInterface();
+NS_ENSURE_TRUE(btInf, false);
+sBluetoothSocketInterface =
+(btsock_interface_t *) btInf->get_profile_interface(BT_PROFILE_SOCKETS_ID);
+NS_ENSURE_TRUE(sBluetoothSocketInterface, false);
+return true;
+}
+static int16_t
+ReadInt16(const uint8_t* aData, size_t* aOffset)
+{
+int16_t value = (aData[*aOffset + 1] << 8) | aData[*aOffset];
+*aOffset += 2;
+return value;
+}
+static int32_t
+ReadInt32(const uint8_t* aData, size_t* aOffset)
+{
+int32_t value = (aData[*aOffset + 3] << 24) |
+(aData[*aOffset + 2] << 16) |
+(aData[*aOffset + 1] << 8) |
+aData[*aOffset];
+*aOffset += 4;
+return value;
+}
+static void
+ReadBdAddress(const uint8_t* aData, size_t* aOffset, nsAString& aDeviceAddress)
+{
+char bdstr[18];
+sprintf(bdstr, "%02x:%02x:%02x:%02x:%02x:%02x",
+aData[*aOffset], aData[*aOffset + 1], aData[*aOffset + 2],
+aData[*aOffset + 3], aData[*aOffset + 4], aData[*aOffset + 5]);
+aDeviceAddress.AssignLiteral(bdstr);
+*aOffset += 6;
+}
+class mozilla::dom::bluetooth::DroidSocketImpl
+: public MessageLoopForIO::Watcher
+{
+public:
+DroidSocketImpl(BluetoothSocket* aConsumer, int aFd)
+: mConsumer(aConsumer)
+, mReadMsgForClientFd(false)
+, mIOLoop(nullptr)
+, mFd(aFd)
+, mShuttingDownOnIOThread(false)
+, mChannel(0)
+, mAuth(false)
+, mEncrypt(false)
+{
+}
+DroidSocketImpl(BluetoothSocket* aConsumer,
+int aChannel, bool aAuth, bool aEncrypt)
+: mConsumer(aConsumer)
+, mReadMsgForClientFd(false)
+, mIOLoop(nullptr)
+, mFd(-1)
+, mShuttingDownOnIOThread(false)
+, mChannel(aChannel)
+, mAuth(aAuth)
+, mEncrypt(aEncrypt)
+{ }
+DroidSocketImpl(BluetoothSocket* aConsumer, const nsAString& aDeviceAddress,
+int aChannel, bool aAuth, bool aEncrypt)
+: mConsumer(aConsumer)
+, mReadMsgForClientFd(false)
+, mIOLoop(nullptr)
+, mFd(-1)
+, mShuttingDownOnIOThread(false)
+, mDeviceAddress(aDeviceAddress)
+, mChannel(aChannel)
+, mAuth(aAuth)
+, mEncrypt(aEncrypt)
+{
+MOZ_ASSERT(!mDeviceAddress.IsEmpty());
+}
+~DroidSocketImpl()
+{
+MOZ_ASSERT(NS_IsMainThread());
+}
+void QueueWriteData(UnixSocketRawData* aData)
+{
+mOutgoingQ.AppendElement(aData);
+OnFileCanWriteWithoutBlocking(mFd);
+}
+bool IsShutdownOnMainThread()
+{
+MOZ_ASSERT(NS_IsMainThread());
+return mConsumer == nullptr;
+}
+bool IsShutdownOnIOThread()
+{
+return mShuttingDownOnIOThread;
+}
+void ShutdownOnMainThread()
+{
+MOZ_ASSERT(NS_IsMainThread());
+MOZ_ASSERT(!IsShutdownOnMainThread());
+mConsumer = nullptr;
+}
+void ShutdownOnIOThread()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+MOZ_ASSERT(!mShuttingDownOnIOThread);
+mReadWatcher.StopWatchingFileDescriptor();
+mWriteWatcher.StopWatchingFileDescriptor();
+mShuttingDownOnIOThread = true;
+}
+void Connect();
+void Listen();
+void SetUpIO(bool aWrite)
+{
+MOZ_ASSERT(!mIOLoop);
+MOZ_ASSERT(mFd >= 0);
+mIOLoop = MessageLoopForIO::current();
+// Set up a read watch
+mIOLoop->WatchFileDescriptor(mFd,
+true,
+MessageLoopForIO::WATCH_READ,
+&mReadWatcher,
+this);
+if (aWrite) {
+// Set up a write watch
+mIOLoop->WatchFileDescriptor(mFd.get(),
+false,
+MessageLoopForIO::WATCH_WRITE,
+&mWriteWatcher,
+this);
+}
+}
+void ConnectClientFd()
+{
+// Stop current read watch
+mReadWatcher.StopWatchingFileDescriptor();
+mIOLoop = nullptr;
+// Restart read & write watch on client fd
+SetUpIO(true);
+}
+/**
+* Consumer pointer. Non-thread safe RefPtr, so should only be manipulated
+* directly from main thread. All non-main-thread accesses should happen with
+* mImpl as container.
+*/
+RefPtr<BluetoothSocket> mConsumer;
+/**
+* If true, read message header to get client fd.
+*/
+bool mReadMsgForClientFd;
+private:
+/**
+* libevent triggered functions that reads data from socket when available and
+* guarenteed non-blocking. Only to be called on IO thread.
+*
+* @param aFd [in] File descriptor to read from
+*/
+virtual void OnFileCanReadWithoutBlocking(int aFd);
+/**
+* libevent or developer triggered functions that writes data to socket when
+* available and guarenteed non-blocking. Only to be called on IO thread.
+*
+* @param aFd [in] File descriptor to read from
+*/
+virtual void OnFileCanWriteWithoutBlocking(int aFd);
+/**
+* Read message to get data and client fd wrapped in message header
+*
+* @param aFd     [in]  File descriptor to read message from
+* @param aBuffer [out] Data buffer read
+* @param aLength [out] Number of bytes read
+*/
+ssize_t ReadMsg(int aFd, void *aBuffer, size_t aLength);
+/**
+* IO Loop pointer. Must be initalized and called from IO thread only.
+*/
+MessageLoopForIO* mIOLoop;
+/**
+* Raw data queue. Must be pushed/popped from IO thread only.
+*/
+typedef nsTArray<UnixSocketRawData* > UnixSocketRawDataQueue;
+UnixSocketRawDataQueue mOutgoingQ;
+/**
+* Read watcher for libevent. Only to be accessed on IO Thread.
+*/
+MessageLoopForIO::FileDescriptorWatcher mReadWatcher;
+/**
+* Write watcher for libevent. Only to be accessed on IO Thread.
+*/
+MessageLoopForIO::FileDescriptorWatcher mWriteWatcher;
+/**
+* File descriptor to read from/write to. Connection happens on user provided
+* thread. Read/write/close happens on IO thread.
+*/
+mozilla::ScopedClose mFd;
+/**
+* If true, do not requeue whatever task we're running
+*/
+bool mShuttingDownOnIOThread;
+nsString mDeviceAddress;
+int mChannel;
+bool mAuth;
+bool mEncrypt;
+};
+template<class T>
+class DeleteInstanceRunnable : public nsRunnable
+{
+public:
+DeleteInstanceRunnable(T* aInstance)
+: mInstance(aInstance)
+{ }
+NS_IMETHOD Run()
+{
+delete mInstance;
+return NS_OK;
+}
+private:
+T* mInstance;
+};
+class RequestClosingSocketTask : public nsRunnable
+{
+public:
+RequestClosingSocketTask(DroidSocketImpl* aImpl) : mImpl(aImpl)
+{
+MOZ_ASSERT(aImpl);
+}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(NS_IsMainThread());
+if (mImpl->IsShutdownOnMainThread()) {
+NS_WARNING("CloseSocket has already been called!");
+// Since we've already explicitly closed and the close happened before
+// this, this isn't really an error. Since we've warned, return OK.
+return NS_OK;
+}
+// Start from here, same handling flow as calling CloseSocket() from
+// upper layer
+mImpl->mConsumer->CloseDroidSocket();
+return NS_OK;
+}
+private:
+DroidSocketImpl* mImpl;
+};
+class ShutdownSocketTask : public Task {
+virtual void Run()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+// At this point, there should be no new events on the IO thread after this
+// one with the possible exception of a SocketAcceptTask that
+// ShutdownOnIOThread will cancel for us. We are now fully shut down, so we
+// can send a message to the main thread that will delete mImpl safely knowing
+// that no more tasks reference it.
+mImpl->ShutdownOnIOThread();
+nsRefPtr<nsIRunnable> t(new DeleteInstanceRunnable<
+mozilla::dom::bluetooth::DroidSocketImpl>(mImpl));
+nsresult rv = NS_DispatchToMainThread(t);
+NS_ENSURE_SUCCESS_VOID(rv);
+}
+DroidSocketImpl* mImpl;
+public:
+ShutdownSocketTask(DroidSocketImpl* aImpl) : mImpl(aImpl) { }
+};
+class SocketReceiveTask : public nsRunnable
+{
+public:
+SocketReceiveTask(DroidSocketImpl* aImpl, UnixSocketRawData* aData) :
+mImpl(aImpl),
+mRawData(aData)
+{
+MOZ_ASSERT(aImpl);
+MOZ_ASSERT(aData);
+}
+NS_IMETHOD Run()
+{
+MOZ_ASSERT(NS_IsMainThread());
+if (mImpl->IsShutdownOnMainThread()) {
+NS_WARNING("mConsumer is null, aborting receive!");
+// Since we've already explicitly closed and the close happened before
+// this, this isn't really an error. Since we've warned, return OK.
+return NS_OK;
+}
+MOZ_ASSERT(mImpl->mConsumer);
+mImpl->mConsumer->ReceiveSocketData(mRawData);
+return NS_OK;
+}
+private:
+DroidSocketImpl* mImpl;
+nsAutoPtr<UnixSocketRawData> mRawData;
+};
+class SocketSendTask : public Task
+{
+public:
+SocketSendTask(BluetoothSocket* aConsumer, DroidSocketImpl* aImpl,
+UnixSocketRawData* aData)
+: mConsumer(aConsumer),
+mImpl(aImpl),
+mData(aData)
+{
+MOZ_ASSERT(aConsumer);
+MOZ_ASSERT(aImpl);
+MOZ_ASSERT(aData);
+}
+void
+Run()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+MOZ_ASSERT(!mImpl->IsShutdownOnIOThread());
+mImpl->QueueWriteData(mData);
+}
+private:
+nsRefPtr<BluetoothSocket> mConsumer;
+DroidSocketImpl* mImpl;
+UnixSocketRawData* mData;
+};
+class DroidSocketImplTask : public CancelableTask
+{
+public:
+DroidSocketImpl* GetDroidSocketImpl() const
+{
+return mDroidSocketImpl;
+}
+void Cancel() MOZ_OVERRIDE
+{
+mDroidSocketImpl = nullptr;
+}
+bool IsCanceled() const
+{
+return !mDroidSocketImpl;
+}
+protected:
+DroidSocketImplTask(DroidSocketImpl* aDroidSocketImpl)
+: mDroidSocketImpl(aDroidSocketImpl)
+{
+MOZ_ASSERT(mDroidSocketImpl);
+}
+private:
+DroidSocketImpl* mDroidSocketImpl;
+};
+class SocketConnectTask : public DroidSocketImplTask
+{
+public:
+SocketConnectTask(DroidSocketImpl* aDroidSocketImpl)
+: DroidSocketImplTask(aDroidSocketImpl)
+{ }
+void Run() MOZ_OVERRIDE
+{
+MOZ_ASSERT(!NS_IsMainThread());
+MOZ_ASSERT(!IsCanceled());
+GetDroidSocketImpl()->Connect();
+}
+};
+class SocketListenTask : public DroidSocketImplTask
+{
+public:
+SocketListenTask(DroidSocketImpl* aDroidSocketImpl)
+: DroidSocketImplTask(aDroidSocketImpl)
+{ }
+void Run() MOZ_OVERRIDE
+{
+MOZ_ASSERT(!NS_IsMainThread());
+if (!IsCanceled()) {
+GetDroidSocketImpl()->Listen();
+}
+}
+};
+class SocketConnectClientFdTask : public Task
+{
+virtual void Run()
+{
+MOZ_ASSERT(!NS_IsMainThread());
+mImpl->ConnectClientFd();
+}
+DroidSocketImpl* mImpl;
+public:
+SocketConnectClientFdTask(DroidSocketImpl* aImpl) : mImpl(aImpl) { }
+};
+void
+DroidSocketImpl::Connect()
+{
+MOZ_ASSERT(sBluetoothSocketInterface);
+bt_bdaddr_t remoteBdAddress;
+StringToBdAddressType(mDeviceAddress, &remoteBdAddress);
+// TODO: uuid as argument
+int fd = -1;
+bt_status_t status =
+sBluetoothSocketInterface->connect(&remoteBdAddress,
+BTSOCK_RFCOMM,
+UUID_OBEX_OBJECT_PUSH,
+mChannel,
+&fd,
+(BTSOCK_FLAG_ENCRYPT * mEncrypt) |
+(BTSOCK_FLAG_AUTH * mAuth));
+NS_ENSURE_TRUE_VOID(status == BT_STATUS_SUCCESS);
+NS_ENSURE_TRUE_VOID(fd >= 0);
+mFd = fd;
+MOZ_ASSERT(!mIOLoop);
+mIOLoop = MessageLoopForIO::current();
+// Set up a read watch
+mIOLoop->WatchFileDescriptor(mFd.get(),
+true,
+MessageLoopForIO::WATCH_READ,
+&mReadWatcher,
+this);
+// Set up a write watch
+mIOLoop->WatchFileDescriptor(mFd.get(),
+false,
+MessageLoopForIO::WATCH_WRITE,
+&mWriteWatcher,
+this);
+}
+void
+DroidSocketImpl::Listen()
+{
+MOZ_ASSERT(sBluetoothSocketInterface);
+// TODO: uuid and service name as arguments
+int fd = -1;
+bt_status_t status =
+sBluetoothSocketInterface->listen(BTSOCK_RFCOMM,
+"OBEX Object Push",
+UUID_OBEX_OBJECT_PUSH,
+mChannel,
+&fd,
+(BTSOCK_FLAG_ENCRYPT * mEncrypt) |
+(BTSOCK_FLAG_AUTH * mAuth));
+NS_ENSURE_TRUE_VOID(status == BT_STATUS_SUCCESS);
+NS_ENSURE_TRUE_VOID(fd >= 0);
+mFd = fd;
+MOZ_ASSERT(!mIOLoop);
+mIOLoop = MessageLoopForIO::current();
+// Set up a read watch
+mIOLoop->WatchFileDescriptor(mFd.get(),
+true,
+MessageLoopForIO::WATCH_READ,
+&mReadWatcher,
+this);
+}
+ssize_t
+DroidSocketImpl::ReadMsg(int aFd, void *aBuffer, size_t aLength)
+{
+ssize_t ret;
+struct msghdr msg;
+struct iovec iv;
+struct cmsghdr cmsgbuf[2 * sizeof(cmsghdr) + 0x100];
+memset(&msg, 0, sizeof(msg));
+memset(&iv, 0, sizeof(iv));
+iv.iov_base = (unsigned char *)aBuffer;
+iv.iov_len = aLength;
+msg.msg_iov = &iv;
+msg.msg_iovlen = 1;
+msg.msg_control = cmsgbuf;
+msg.msg_controllen = sizeof(cmsgbuf);
+ret = recvmsg(mFd.get(), &msg, MSG_NOSIGNAL);
+if (ret < 0 && errno == EPIPE) {
+// Treat this as an end of stream
+return 0;
+}
+NS_ENSURE_FALSE(ret < 0, -1);
+NS_ENSURE_FALSE(msg.msg_flags & (MSG_CTRUNC | MSG_OOB | MSG_ERRQUEUE), -1);
+// Extract client fd from message header
+for (struct cmsghdr *cmsgptr = CMSG_FIRSTHDR(&msg);
+cmsgptr != nullptr; cmsgptr = CMSG_NXTHDR(&msg, cmsgptr)) {
+if (cmsgptr->cmsg_level != SOL_SOCKET) {
+continue;
+}
+if (cmsgptr->cmsg_type == SCM_RIGHTS) {
+int *pDescriptors = (int *)CMSG_DATA(cmsgptr);
+// Overwrite fd with client fd
+mFd.reset(pDescriptors[0]);
+break;
+}
+}
+return ret;
+}
+void
+DroidSocketImpl::OnFileCanReadWithoutBlocking(int aFd)
+{
+MOZ_ASSERT(!NS_IsMainThread());
+MOZ_ASSERT(!mShuttingDownOnIOThread);
+// Read all of the incoming data.
+while (true) {
+nsAutoPtr<UnixSocketRawData> incoming(new UnixSocketRawData(MAX_READ_SIZE));
+ssize_t ret;
+if (!mReadMsgForClientFd) {
+ret = read(aFd, incoming->mData, incoming->mSize);
+} else {
+ret = ReadMsg(aFd, incoming->mData, incoming->mSize);
+}
+if (ret <= 0) {
+if (ret == -1) {
+if (errno == EINTR) {
+continue; // retry system call when interrupted
+}
+if (errno == EAGAIN || errno == EWOULDBLOCK) {
+return; // no data available: return and re-poll
+}
+BT_WARNING("Cannot read from network");
+// else fall through to error handling on other errno's
+}
+// We're done with our descriptors. Ensure that spurious events don't
+// cause us to end up back here.
+mReadWatcher.StopWatchingFileDescriptor();
+mWriteWatcher.StopWatchingFileDescriptor();
+nsRefPtr<RequestClosingSocketTask> t = new RequestClosingSocketTask(this);
+NS_DispatchToMainThread(t);
+return;
+}
+incoming->mSize = ret;
+nsRefPtr<SocketReceiveTask> t =
+new SocketReceiveTask(this, incoming.forget());
+NS_DispatchToMainThread(t);
+// If ret is less than MAX_READ_SIZE, there's no
+// more data in the socket for us to read now.
+if (ret < ssize_t(MAX_READ_SIZE)) {
+return;
+}
+}
+MOZ_CRASH("We returned early");
+}
+void
+DroidSocketImpl::OnFileCanWriteWithoutBlocking(int aFd)
+{
+MOZ_ASSERT(!NS_IsMainThread());
+MOZ_ASSERT(!mShuttingDownOnIOThread);
+MOZ_ASSERT(aFd >= 0);
+// Try to write the bytes of mCurrentRilRawData.  If all were written, continue.
+//
+// Otherwise, save the byte position of the next byte to write
+// within mCurrentWriteOffset, and request another write when the
+// system won't block.
+//
+while (true) {
+UnixSocketRawData* data;
+if (mOutgoingQ.IsEmpty()) {
+return;
+}
+data = mOutgoingQ.ElementAt(0);
+const uint8_t *toWrite;
+toWrite = data->mData;
+while (data->mCurrentWriteOffset < data->mSize) {
+ssize_t write_amount = data->mSize - data->mCurrentWriteOffset;
+ssize_t written;
+written = write (aFd, toWrite + data->mCurrentWriteOffset,
+write_amount);
+if (written > 0) {
+data->mCurrentWriteOffset += written;
+}
+if (written != write_amount) {
+break;
+}
+}
+if (data->mCurrentWriteOffset != data->mSize) {
+MessageLoopForIO::current()->WatchFileDescriptor(
+aFd,
+false,
+MessageLoopForIO::WATCH_WRITE,
+&mWriteWatcher,
+this);
+return;
+}
+mOutgoingQ.RemoveElementAt(0);
+delete data;
+}
+}
+BluetoothSocket::BluetoothSocket(BluetoothSocketObserver* aObserver,
+BluetoothSocketType aType,
+bool aAuth,
+bool aEncrypt)
+: mObserver(aObserver)
+, mImpl(nullptr)
+, mAuth(aAuth)
+, mEncrypt(aEncrypt)
+, mReceivedSocketInfoLength(0)
+{
+MOZ_ASSERT(aObserver);
+EnsureBluetoothSocketHalLoad();
+mDeviceAddress.AssignLiteral(BLUETOOTH_ADDRESS_NONE);
+}
+void
+BluetoothSocket::CloseDroidSocket()
+{
+MOZ_ASSERT(NS_IsMainThread());
+if (!mImpl) {
+return;
+}
+// From this point on, we consider mImpl as being deleted.
+// We sever the relationship here so any future calls to listen or connect
+// will create a new implementation.
+mImpl->ShutdownOnMainThread();
+XRE_GetIOMessageLoop()->PostTask(FROM_HERE,
+new ShutdownSocketTask(mImpl));
+mImpl = nullptr;
+OnDisconnect();
+}
+bool
+BluetoothSocket::Connect(const nsAString& aDeviceAddress, int aChannel)
+{
+MOZ_ASSERT(NS_IsMainThread());
+NS_ENSURE_FALSE(mImpl, false);
+mIsServer = false;
+mImpl = new DroidSocketImpl(this, aDeviceAddress, aChannel, mAuth, mEncrypt);
+XRE_GetIOMessageLoop()->PostTask(FROM_HERE,
+new SocketConnectTask(mImpl));
+return true;
+}
+bool
+BluetoothSocket::Listen(int aChannel)
+{
+MOZ_ASSERT(NS_IsMainThread());
+NS_ENSURE_FALSE(mImpl, false);
+mIsServer = true;
+mImpl = new DroidSocketImpl(this, aChannel, mAuth, mEncrypt);
+XRE_GetIOMessageLoop()->PostTask(FROM_HERE,
+new SocketListenTask(mImpl));
+return true;
+}
+bool
+BluetoothSocket::SendDroidSocketData(UnixSocketRawData* aData)
+{
+MOZ_ASSERT(NS_IsMainThread());
+NS_ENSURE_TRUE(mImpl, false);
+MOZ_ASSERT(!mImpl->IsShutdownOnMainThread());
+XRE_GetIOMessageLoop()->PostTask(FROM_HERE,
+new SocketSendTask(this, mImpl, aData));
+return true;
+}
+bool
+BluetoothSocket::ReceiveSocketInfo(nsAutoPtr<UnixSocketRawData>& aMessage)
+{
+MOZ_ASSERT(NS_IsMainThread());
+/**
+* 2 socket info messages (20 bytes) to receive at the beginning:
+* - 1st message: [channel:4]
+* - 2nd message: [size:2][bd address:6][channel:4][connection status:4]
+*/
+if (mReceivedSocketInfoLength >= TOTAL_SOCKET_INFO_LENGTH) {
+// We've got both socket info messages
+return false;
+}
+mReceivedSocketInfoLength += aMessage->mSize;
+size_t offset = 0;
+if (mReceivedSocketInfoLength == FIRST_SOCKET_INFO_MSG_LENGTH) {
+// 1st message: [channel:4]
+int32_t channel = ReadInt32(aMessage->mData, &offset);
+BT_LOGR("channel %d", channel);
+// If this is server socket, read header of next message for client fd
+mImpl->mReadMsgForClientFd = mIsServer;
+} else if (mReceivedSocketInfoLength == TOTAL_SOCKET_INFO_LENGTH) {
+// 2nd message: [size:2][bd address:6][channel:4][connection status:4]
+int16_t size = ReadInt16(aMessage->mData, &offset);
+ReadBdAddress(aMessage->mData, &offset, mDeviceAddress);
+int32_t channel = ReadInt32(aMessage->mData, &offset);
+int32_t connectionStatus = ReadInt32(aMessage->mData, &offset);
+BT_LOGR("size %d channel %d remote addr %s status %d",
+size, channel, NS_ConvertUTF16toUTF8(mDeviceAddress).get(), connectionStatus);
+if (connectionStatus != 0) {
+OnConnectError();
+return true;
+}
+if (mIsServer) {
+mImpl->mReadMsgForClientFd = false;
+// Connect client fd on IO thread
+XRE_GetIOMessageLoop()->PostTask(FROM_HERE,
+new SocketConnectClientFdTask(mImpl));
+}
+OnConnectSuccess();
+}
+return true;
+}
+void
+BluetoothSocket::ReceiveSocketData(nsAutoPtr<UnixSocketRawData>& aMessage)
+{
+if (ReceiveSocketInfo(aMessage)) {
+return;
+}
+MOZ_ASSERT(NS_IsMainThread());
+MOZ_ASSERT(mObserver);
+mObserver->ReceiveSocketData(this, aMessage);
+}
+void
+BluetoothSocket::OnConnectSuccess()
+{
+MOZ_ASSERT(NS_IsMainThread());
+MOZ_ASSERT(mObserver);
+mObserver->OnSocketConnectSuccess(this);
+}
+void
+BluetoothSocket::OnConnectError()
+{
+MOZ_ASSERT(NS_IsMainThread());
+MOZ_ASSERT(mObserver);
+mObserver->OnSocketConnectError(this);
+}
+void
+BluetoothSocket::OnDisconnect()
+{
+MOZ_ASSERT(NS_IsMainThread());
+MOZ_ASSERT(mObserver);
+mObserver->OnSocketDisconnect(this);
+}

The Tor Browser / file comparison

comparison: dom/bluetooth/bluedroid/BluetoothSocket.cpp

dom/bluetooth/bluedroid/BluetoothSocket.cpp