src/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::DoConnect(
 141     const base::Closure& success_callback,
 142     const ErrorCompletionCallback& error_callback) {
 143   DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
 144   base::ThreadRestrictions::AssertIOAllowed();
 145
 146   if (tcp_socket()) {
 147     error_callback.Run(kSocketAlreadyConnected);
 148     return;
 149   }
 150
 151   if (!supports_rfcomm_) {
 152     // TODO(youngki) add support for L2CAP sockets as well.
 153     error_callback.Run(kL2CAPNotSupported);
 154     return;
 155   }
 156
 157   ResetTCPSocket();
 158   net::EnsureWinsockInit();
 159   SOCKET socket_fd = socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
 160   SOCKADDR_BTH sa;
 161   ZeroMemory(&sa, sizeof(sa));
 162   sa.addressFamily = AF_BTH;
 163   sa.port = rfcomm_channel_;
 164   sa.btAddr = bth_addr_;
 165
 166   // TODO(rpaquay): Condider making this call non-blocking.
 167   int status = connect(socket_fd, reinterpret_cast<SOCKADDR*>(&sa), sizeof(sa));
 168   DWORD error_code = WSAGetLastError();
 169   if (!(status == 0 || error_code == WSAEINPROGRESS)) {
 170     LOG(ERROR) << "Failed to connect bluetooth socket "
 171                << "(" << device_address_ << "): "
 172                << logging::SystemErrorCodeToString(error_code);
 173     error_callback.Run("Error connecting to socket: " +
 174                        logging::SystemErrorCodeToString(error_code));
 175     closesocket(socket_fd);
 176     return;
 177   }
 178
 179   // Note: We don't have a meaningful |IPEndPoint|, but that is ok since the
 180   // TCPSocket implementation does not actually require one.
 181   int net_result =
 182       tcp_socket()->AdoptConnectedSocket(socket_fd, net::IPEndPoint());
 183   if (net_result != net::OK) {
 184     error_callback.Run("Error connecting to socket: " +
 185                        std::string(net::ErrorToString(net_result)));
 186     closesocket(socket_fd);
 187     return;
 188   }
 189
 190   success_callback.Run();
 191 }
 192
 193 void BluetoothSocketWin::DoStartService(
 194     const BluetoothUUID& uuid,
 195     const std::string& name,
 196     int rfcomm_channel,
 197     const base::Closure& success_callback,
 198     const ErrorCompletionCallback& error_callback,
 199     const OnNewConnectionCallback& new_connection_callback) {
 200   DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
 201   DCHECK(!tcp_socket() &&
 202          !service_reg_data_ &&
 203          on_new_connection_callback_.is_null());
 204
 205   // The valid range is 0-30. 0 means BT_PORT_ANY and 1-30 are the
 206   // valid RFCOMM port numbers of SOCKADDR_BTH.
 207   if (rfcomm_channel < 0 || rfcomm_channel > 30) {
 208     LOG(WARNING) << "Failed to start service: "
 209                  << "Invalid RFCCOMM port " << rfcomm_channel
 210                  << ", uuid=" << uuid.value();
 211     PostErrorCompletion(error_callback, kInvalidRfcommPort);
 212     return;
 213   }
 214
 215   SOCKET socket_fd = socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
 216   if (socket_fd == INVALID_SOCKET) {
 217     LOG(WARNING) << "Failed to start service: create socket, "
 218                  << "winsock err=" << WSAGetLastError();
 219     PostErrorCompletion(error_callback, kFailedToCreateSocket);
 220     return;
 221   }
 222
 223   // Note that |socket_fd| belongs to a non-TCP address family (i.e. AF_BTH),
 224   // TCPSocket methods that involve address could not be called. So bind()
 225   // is called on |socket_fd| directly.
 226   scoped_ptr<net::TCPSocket> scoped_socket(
 227       new net::TCPSocket(NULL, net::NetLog::Source()));
 228   scoped_socket->AdoptListenSocket(socket_fd);
 229
 230   SOCKADDR_BTH sa;
 231   struct sockaddr* sock_addr = reinterpret_cast<struct sockaddr*>(&sa);
 232   int sock_addr_len = sizeof(sa);
 233   ZeroMemory(&sa, sock_addr_len);
 234   sa.addressFamily = AF_BTH;
 235   sa.port = rfcomm_channel ? rfcomm_channel : BT_PORT_ANY;
 236   if (bind(socket_fd, sock_addr, sock_addr_len) < 0) {
 237     LOG(WARNING) << "Failed to start service: create socket, "
 238                  << "winsock err=" << WSAGetLastError();
 239     PostErrorCompletion(error_callback, kFailedToBindSocket);
 240     return;
 241   }
 242
 243   const int kListenBacklog = 5;
 244   if (scoped_socket->Listen(kListenBacklog) < 0) {
 245     LOG(WARNING) << "Failed to start service: Listen"
 246                  << "winsock err=" << WSAGetLastError();
 247     PostErrorCompletion(error_callback, kFailedToListenOnSocket);
 248     return;
 249   }
 250
 251   scoped_ptr<ServiceRegData> reg_data(new ServiceRegData);
 252   reg_data->name = base::UTF8ToUTF16(name);
 253
 254   if (getsockname(socket_fd, sock_addr, &sock_addr_len)) {
 255     LOG(WARNING) << "Failed to start service: getsockname, "
 256                  << "winsock err=" << WSAGetLastError();
 257     PostErrorCompletion(error_callback, kFailedToGetSockNameForSocket);
 258     return;
 259   }
 260   reg_data->address = sa;
 261
 262   reg_data->address_info.LocalAddr.iSockaddrLength = sizeof(sa);
 263   reg_data->address_info.LocalAddr.lpSockaddr =
 264       reinterpret_cast<struct sockaddr*>(&reg_data->address);
 265   reg_data->address_info.iSocketType = SOCK_STREAM;
 266   reg_data->address_info.iProtocol = BTHPROTO_RFCOMM;
 267
 268   base::string16 cannonical_uuid = L"{" + base::ASCIIToUTF16(
 269       uuid.canonical_value()) + L"}";
 270   if (!SUCCEEDED(CLSIDFromString(cannonical_uuid.c_str(), &reg_data->uuid))) {
 271     LOG(WARNING) << "Failed to start service: "
 272                  << ", bad uuid=" << cannonical_uuid;
 273     PostErrorCompletion(error_callback, kBadUuid);
 274     return;
 275   }
 276
 277   reg_data->service.dwSize = sizeof(WSAQUERYSET);
 278   reg_data->service.lpszServiceInstanceName =
 279       const_cast<LPWSTR>(reg_data->name.c_str());
 280   reg_data->service.lpServiceClassId = &reg_data->uuid;
 281   reg_data->service.dwNameSpace = NS_BTH;
 282   reg_data->service.dwNumberOfCsAddrs = 1;
 283   reg_data->service.lpcsaBuffer = &reg_data->address_info;
 284
 285   if (WSASetService(&reg_data->service,
 286                     RNRSERVICE_REGISTER, 0) == SOCKET_ERROR) {
 287     LOG(WARNING) << "Failed to register profile: WSASetService"
 288                  << "winsock err=" << WSAGetLastError();
 289     PostErrorCompletion(error_callback, kWsaSetServiceError);
 290     return;
 291   }
 292
 293   SetTCPSocket(scoped_socket.Pass());
 294   service_reg_data_ = reg_data.Pass();
 295   on_new_connection_callback_ = new_connection_callback;
 296   DoAccept();
 297
 298   PostSuccess(success_callback);
 299 }
 300
 301 void BluetoothSocketWin::DoAccept() {
 302   DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
 303   int result = tcp_socket()->Accept(
 304       &accept_socket_,
 305       &accept_address_,
 306       base::Bind(&BluetoothSocketWin::OnAcceptOnSocketThread, this));
 307   if (result != net::OK && result != net::ERR_IO_PENDING)
 308     LOG(WARNING) << "Failed to accept, net err=" << result;
 309 }
 310
 311 void BluetoothSocketWin::OnAcceptOnSocketThread(int accept_result) {
 312   DCHECK(socket_thread()->task_runner()->RunsTasksOnCurrentThread());
 313   if (accept_result != net::OK) {
 314     LOG(WARNING) << "OnAccept error, net err=" << accept_result;
 315     return;
 316   }
 317
 318   ui_task_runner()->PostTask(
 319     FROM_HERE,
 320     base::Bind(&BluetoothSocketWin::OnAcceptOnUI,
 321                this,
 322                base::Passed(&accept_socket_),
 323                accept_address_));
 324   DoAccept();
 325 }
 326
 327 void BluetoothSocketWin::OnAcceptOnUI(
 328     scoped_ptr<net::TCPSocket> accept_socket,
 329     const net::IPEndPoint& peer_address) {
 330   DCHECK(ui_task_runner()->RunsTasksOnCurrentThread());
 331
 332   scoped_refptr<BluetoothSocketWin> peer = CreateBluetoothSocket(
 333           ui_task_runner(),
 334           socket_thread(),
 335           net_log(),
 336           source());
 337   peer->SetTCPSocket(accept_socket.Pass());
 338
 339   on_new_connection_callback_.Run(peer, peer_address);
 340 }
 341
 342 }  // namespace device