device/bluetooth/bluetooth_socket_win.cc

   1 // Copyright (c) 2012 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 "device/bluetooth/bluetooth_socket_win.h"
   6
   7 #include <objbase.h>
   8
   9 #include <string>
  10
  11 #include "base/logging.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/sequenced_task_runner.h"
  14 #include "base/strings/sys_string_conversions.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "base/threading/thread_restrictions.h"
  17 #include "device/bluetooth/bluetooth_init_win.h"
  18 #include "device/bluetooth/bluetooth_service_record_win.h"
  19 #include "device/bluetooth/bluetooth_socket_thread.h"
  20 #include "net/base/io_buffer.h"
  21 #include "net/base/ip_endpoint.h"
  22 #include "net/base/net_errors.h"
  23 #include "net/base/winsock_init.h"
  24
  25 namespace {
  26
  27 const char kL2CAPNotSupported[] = "Bluetooth L2CAP protocal is not supported";
  28 const char kSocketAlreadyConnected[] = "Socket is already connected.";
  29 const char kInvalidRfcommPort[] = "Invalid RFCCOMM port.";
  30 const char kFailedToCreateSocket[] = "Failed to create socket.";
  31 const char kFailedToBindSocket[] = "Failed to bind socket.";
  32 const char kFailedToListenOnSocket[] = "Failed to listen on socket.";
  33 const char kFailedToGetSockNameForSocket[] = "Failed to getsockname.";
  34 const char kBadUuid[] = "Bad uuid.";
  35 const char kWsaSetServiceError[] = "WSASetService error.";
  36
  37 }  // namespace
  38
  39 namespace device {
  40
  41 struct BluetoothSocketWin::ServiceRegData {
  42   ServiceRegData() {
  43     ZeroMemory(&address, sizeof(address));
  44     ZeroMemory(&address_info, sizeof(address_info));
  45     ZeroMemory(&uuid, sizeof(uuid));
  46     ZeroMemory(&service, sizeof(service));
  47   }
  48
  49   SOCKADDR_BTH address;
  50   CSADDR_INFO address_info;
  51   GUID uuid;
  52   base::string16 name;
  53   WSAQUERYSET service;
  54 };
  55
  56 // static
  57 scoped_refptr<BluetoothSocketWin>
  58 BluetoothSocketWin::CreateBluetoothSocket(
  59     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
  60     scoped_refptr<device::BluetoothSocketThread> socket_thread,
  61     net::NetLog* net_log,
  62     const net::NetLog::Source& source) {
  63   DCHECK(ui_task_runner->RunsTasksOnCurrentThread());
  64
  65   return make_scoped_refptr(
  66       new BluetoothSocketWin(ui_task_runner, socket_thread, net_log, source));
  67 }
  68
  69 BluetoothSocketWin::BluetoothSocketWin(
  70     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
  71     scoped_refptr<BluetoothSocketThread> socket_thread,
  72     net::NetLog* net_log,
  73     const net::NetLog::Source& source)
  74     : BluetoothSocketNet(ui_task_runner, socket_thread, net_log, source),
  75       supports_rfcomm_(false),
  76       rfcomm_channel_(-1),
  77       bth_addr_(BTH_ADDR_NULL) {
  78 }
  79
  80 BluetoothSocketWin::~BluetoothSocketWin() {
  81 }
  82
  83 void BluetoothSocketWin::StartService(
  84     const BluetoothUUID& uuid,
  85     const std::string& name,
  86     int rfcomm_channel,
  87     const base::Closure& success_callback,
  88     const ErrorCompletionCallback& error_callback,
  89     const OnNewConnectionCallback& new_connection_callback) {
  90   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
  91
  92   socket_thread()->task_runner()->PostTask(
  93       FROM_HERE,
  94       base::Bind(&BluetoothSocketWin::DoStartService,
  95                  this,
  96                  uuid,
  97                  name,
  98                  rfcomm_channel,
  99                  success_callback,
 100                  error_callback,
 101                  new_connection_callback));
 102 }
 103
 104 void BluetoothSocketWin::Connect(
 105     const BluetoothServiceRecord& service_record,
 106     const base::Closure& success_callback,
 107     const ErrorCompletionCallback& error_callback) {
 108   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 109
 110   const BluetoothServiceRecordWin* service_record_win =
 111       static_cast<const BluetoothServiceRecordWin*>(&service_record);
 112   device_address_ = service_record_win->address();
 113   if (service_record.SupportsRfcomm()) {
 114     supports_rfcomm_ = true;
 115     rfcomm_channel_ = service_record_win->rfcomm_channel();
 116     bth_addr_ = service_record_win->bth_addr();
 117   }
 118
 119   socket_thread()->task_runner()->PostTask(
 120       FROM_HERE,
 121       base::Bind(
 122           &BluetoothSocketWin::DoConnect,
 123           this,
 124           base::Bind(&BluetoothSocketWin::PostSuccess, this, success_callback),
 125           base::Bind(
 126               &BluetoothSocketWin::PostErrorCompletion, this, error_callback)));
 127 }
 128
 129
 130 void BluetoothSocketWin::ResetData() {
 131   if (service_reg_data_) {
 132     if (WSASetService(&service_reg_data_->service,RNRSERVICE_DELETE, 0) ==
 133         SOCKET_ERROR) {
 134       LOG(WARNING) << "Failed to unregister service.";
 135     }
 136     service_reg_data_.reset();
 137   }
 138 }
 139
 140 void BluetoothSocketWin::Accept(
 141     const AcceptCompletionCallback& success_callback,
 142     const ErrorCompletionCallback& error_callback) {
 143   NOTIMPLEMENTED();
 144 }
 145
 146 void BluetoothSocketWin::DoConnect(
 147     const base::Closure& success_callback,
 148     const ErrorCompletionCallback& error_callback) {
 149   DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
 150   base::ThreadRestrictions::AssertIOAllowed();
 151
 152   if (tcp_socket()) {
 153     error_callback.Run(kSocketAlreadyConnected);
 154     return;
 155   }
 156
 157   if (!supports_rfcomm_) {
 158     // TODO(youngki) add support for L2CAP sockets as well.
 159     error_callback.Run(kL2CAPNotSupported);
 160     return;
 161   }
 162
 163   ResetTCPSocket();
 164   net::EnsureWinsockInit();
 165   SOCKET socket_fd = socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
 166   SOCKADDR_BTH sa;
 167   ZeroMemory(&sa, sizeof(sa));
 168   sa.addressFamily = AF_BTH;
 169   sa.port = rfcomm_channel_;
 170   sa.btAddr = bth_addr_;
 171
 172   // TODO(rpaquay): Condider making this call non-blocking.
 173   int status = connect(socket_fd, reinterpret_cast<SOCKADDR*>(&sa), sizeof(sa));
 174   DWORD error_code = WSAGetLastError();
 175   if (!(status == 0 || error_code == WSAEINPROGRESS)) {
 176     LOG(ERROR) << "Failed to connect bluetooth socket "
 177                << "(" << device_address_ << "): "
 178                << logging::SystemErrorCodeToString(error_code);
 179     error_callback.Run("Error connecting to socket: " +
 180                        logging::SystemErrorCodeToString(error_code));
 181     closesocket(socket_fd);
 182     return;
 183   }
 184
 185   // Note: We don't have a meaningful |IPEndPoint|, but that is ok since the
 186   // TCPSocket implementation does not actually require one.
 187   int net_result =
 188       tcp_socket()->AdoptConnectedSocket(socket_fd, net::IPEndPoint());
 189   if (net_result != net::OK) {
 190     error_callback.Run("Error connecting to socket: " +
 191                        std::string(net::ErrorToString(net_result)));
 192     closesocket(socket_fd);
 193     return;
 194   }
 195
 196   success_callback.Run();
 197 }
 198
 199 void BluetoothSocketWin::DoStartService(
 200     const BluetoothUUID& uuid,
 201     const std::string& name,
 202     int rfcomm_channel,
 203     const base::Closure& success_callback,
 204     const ErrorCompletionCallback& error_callback,
 205     const OnNewConnectionCallback& new_connection_callback) {
 206   DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
 207   DCHECK(!tcp_socket() &&
 208          !service_reg_data_ &&
 209          on_new_connection_callback_.is_null());
 210
 211   // The valid range is 0-30. 0 means BT_PORT_ANY and 1-30 are the
 212   // valid RFCOMM port numbers of SOCKADDR_BTH.
 213   if (rfcomm_channel < 0 || rfcomm_channel > 30) {
 214     LOG(WARNING) << "Failed to start service: "
 215                  << "Invalid RFCCOMM port " << rfcomm_channel
 216                  << ", uuid=" << uuid.value();
 217     PostErrorCompletion(error_callback, kInvalidRfcommPort);
 218     return;
 219   }
 220
 221   SOCKET socket_fd = socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
 222   if (socket_fd == INVALID_SOCKET) {
 223     LOG(WARNING) << "Failed to start service: create socket, "
 224                  << "winsock err=" << WSAGetLastError();
 225     PostErrorCompletion(error_callback, kFailedToCreateSocket);
 226     return;
 227   }
 228
 229   // Note that |socket_fd| belongs to a non-TCP address family (i.e. AF_BTH),
 230   // TCPSocket methods that involve address could not be called. So bind()
 231   // is called on |socket_fd| directly.
 232   scoped_ptr<net::TCPSocket> scoped_socket(
 233       new net::TCPSocket(NULL, net::NetLog::Source()));
 234   scoped_socket->AdoptListenSocket(socket_fd);
 235
 236   SOCKADDR_BTH sa;
 237   struct sockaddr* sock_addr = reinterpret_cast<struct sockaddr*>(&sa);
 238   int sock_addr_len = sizeof(sa);
 239   ZeroMemory(&sa, sock_addr_len);
 240   sa.addressFamily = AF_BTH;
 241   sa.port = rfcomm_channel ? rfcomm_channel : BT_PORT_ANY;
 242   if (bind(socket_fd, sock_addr, sock_addr_len) < 0) {
 243     LOG(WARNING) << "Failed to start service: create socket, "
 244                  << "winsock err=" << WSAGetLastError();
 245     PostErrorCompletion(error_callback, kFailedToBindSocket);
 246     return;
 247   }
 248
 249   const int kListenBacklog = 5;
 250   if (scoped_socket->Listen(kListenBacklog) < 0) {
 251     LOG(WARNING) << "Failed to start service: Listen"
 252                  << "winsock err=" << WSAGetLastError();
 253     PostErrorCompletion(error_callback, kFailedToListenOnSocket);
 254     return;
 255   }
 256
 257   scoped_ptr<ServiceRegData> reg_data(new ServiceRegData);
 258   reg_data->name = base::UTF8ToUTF16(name);
 259
 260   if (getsockname(socket_fd, sock_addr, &sock_addr_len)) {
 261     LOG(WARNING) << "Failed to start service: getsockname, "
 262                  << "winsock err=" << WSAGetLastError();
 263     PostErrorCompletion(error_callback, kFailedToGetSockNameForSocket);
 264     return;
 265   }
 266   reg_data->address = sa;
 267
 268   reg_data->address_info.LocalAddr.iSockaddrLength = sizeof(sa);
 269   reg_data->address_info.LocalAddr.lpSockaddr =
 270       reinterpret_cast<struct sockaddr*>(&reg_data->address);
 271   reg_data->address_info.iSocketType = SOCK_STREAM;
 272   reg_data->address_info.iProtocol = BTHPROTO_RFCOMM;
 273
 274   base::string16 cannonical_uuid = L"{" + base::ASCIIToUTF16(
 275       uuid.canonical_value()) + L"}";
 276   if (!SUCCEEDED(CLSIDFromString(cannonical_uuid.c_str(), &reg_data->uuid))) {
 277     LOG(WARNING) << "Failed to start service: "
 278                  << ", bad uuid=" << cannonical_uuid;
 279     PostErrorCompletion(error_callback, kBadUuid);
 280     return;
 281   }
 282
 283   reg_data->service.dwSize = sizeof(WSAQUERYSET);
 284   reg_data->service.lpszServiceInstanceName =
 285       const_cast<LPWSTR>(reg_data->name.c_str());
 286   reg_data->service.lpServiceClassId = &reg_data->uuid;
 287   reg_data->service.dwNameSpace = NS_BTH;
 288   reg_data->service.dwNumberOfCsAddrs = 1;
 289   reg_data->service.lpcsaBuffer = &reg_data->address_info;
 290
 291   if (WSASetService(&reg_data->service,
 292                     RNRSERVICE_REGISTER, 0) == SOCKET_ERROR) {
 293     LOG(WARNING) << "Failed to register profile: WSASetService"
 294                  << "winsock err=" << WSAGetLastError();
 295     PostErrorCompletion(error_callback, kWsaSetServiceError);
 296     return;
 297   }
 298
 299   SetTCPSocket(scoped_socket.Pass());
 300   service_reg_data_ = reg_data.Pass();
 301   on_new_connection_callback_ = new_connection_callback;
 302   DoAccept();
 303
 304   PostSuccess(success_callback);
 305 }
 306
 307 void BluetoothSocketWin::DoAccept() {
 308   DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
 309   int result = tcp_socket()->Accept(
 310       &accept_socket_,
 311       &accept_address_,
 312       base::Bind(&BluetoothSocketWin::OnAcceptOnSocketThread, this));
 313   if (result != net::OK && result != net::ERR_IO_PENDING)
 314     LOG(WARNING) << "Failed to accept, net err=" << result;
 315 }
 316
 317 void BluetoothSocketWin::OnAcceptOnSocketThread(int accept_result) {
 318   DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
 319   if (accept_result != net::OK) {
 320     LOG(WARNING) << "OnAccept error, net err=" << accept_result;
 321     return;
 322   }
 323
 324   ui_task_runner()->PostTask(
 325     FROM_HERE,
 326     base::Bind(&BluetoothSocketWin::OnAcceptOnUI,
 327                this,
 328                base::Passed(&accept_socket_),
 329                accept_address_));
 330   DoAccept();
 331 }
 332
 333 void BluetoothSocketWin::OnAcceptOnUI(
 334     scoped_ptr<net::TCPSocket> accept_socket,
 335     const net::IPEndPoint& peer_address) {
 336   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 337
 338   scoped_refptr<BluetoothSocketWin> peer = CreateBluetoothSocket(
 339           ui_task_runner(),
 340           socket_thread(),
 341           net_log(),
 342           source());
 343   peer->SetTCPSocket(accept_socket.Pass());
 344
 345   on_new_connection_callback_.Run(peer, peer_address);
 346 }
 347
 348 }  // namespace device