sd/source/ui/remotecontrol/BluetoothServer.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include "BluetoothServer.hxx"
  11
  12 #include <iostream>
  13 #include <iomanip>
  14 #include <memory>
  15 #include <new>
  16
  17 #include <sal/log.hxx>
  18 #include <osl/socket.hxx>
  19
  20 #ifdef LINUX_BLUETOOTH
  21   #include <glib.h>
  22   #include <dbus/dbus.h>
  23   #include <errno.h>
  24   #include <fcntl.h>
  25   #include <sys/unistd.h>
  26   #include <sys/socket.h>
  27   #include <bluetooth/bluetooth.h>
  28   #include <bluetooth/rfcomm.h>
  29   #include "BluetoothServiceRecord.hxx"
  30   #include "BufferedStreamSocket.hxx"
  31 #endif
  32
  33 #ifdef _WIN32
  34   // LO vs WinAPI conflict
  35   #undef WB_LEFT
  36   #undef WB_RIGHT
  37   #include <winsock2.h>
  38   #include <ws2bth.h>
  39   #include "BufferedStreamSocket.hxx"
  40 #endif
  41
  42 #ifdef MACOSX
  43   #include <osl/conditn.hxx>
  44   #include <premac.h>
  45   #import <CoreFoundation/CoreFoundation.h>
  46   #import <IOBluetooth/IOBluetoothUtilities.h>
  47   #import <IOBluetooth/objc/IOBluetoothSDPUUID.h>
  48   #import <IOBluetooth/objc/IOBluetoothSDPServiceRecord.h>
  49   #include <postmac.h>
  50   #import "OSXBluetooth.h"
  51   #include "OSXBluetoothWrapper.hxx"
  52 #endif
  53
  54 #include "Communicator.hxx"
  55
  56 using namespace sd;
  57
  58 #ifdef LINUX_BLUETOOTH
  59
  60 struct DBusObject {
  61     OString maBusName;
  62     OString maPath;
  63     OString maInterface;
  64
  65     DBusObject() { }
  66     DBusObject( const char *pBusName, const char *pPath, const char *pInterface )
  67         : maBusName( pBusName ), maPath( pPath ), maInterface( pInterface ) { }
  68
  69     DBusMessage *getMethodCall( const char *pName )
  70     {
  71         return dbus_message_new_method_call( maBusName.getStr(), maPath.getStr(),
  72                                              maInterface.getStr(), pName );
  73     }
  74     std::unique_ptr<DBusObject> cloneForInterface( const char *pInterface )
  75     {
  76         std::unique_ptr<DBusObject> pObject(new DBusObject());
  77
  78         pObject->maBusName = maBusName;
  79         pObject->maPath = maPath;
  80         pObject->maInterface = pInterface;
  81
  82         return pObject;
  83     }
  84 };
  85
  86 static std::unique_ptr<DBusObject> getBluez5Adapter(DBusConnection *pConnection);
  87
  88 struct sd::BluetoothServer::Impl {
  89     // the glib mainloop running in the thread
  90     GMainContext *mpContext;
  91     DBusConnection *mpConnection;
  92     std::unique_ptr<DBusObject> mpService;
  93     enum class BluezVersion { BLUEZ4, BLUEZ5, UNKNOWN };
  94     BluezVersion maBluezVersion;
  95
  96     Impl()
  97         : mpContext( g_main_context_new() )
  98         , mpConnection( nullptr )
  99         , maBluezVersion( BluezVersion::UNKNOWN )
 100     { }
 101
 102     std::unique_ptr<DBusObject> getAdapter()
 103     {
 104         if (mpService)
 105         {
 106             return mpService->cloneForInterface( "org.bluez.Adapter" );
 107         }
 108         else if (spServer->mpImpl->maBluezVersion == BluezVersion::BLUEZ5)
 109         {
 110             return getBluez5Adapter(mpConnection);
 111         }
 112         else
 113         {
 114             return nullptr;
 115         }
 116     }
 117 };
 118
 119 static DBusConnection *
 120 dbusConnectToNameOnBus()
 121 {
 122     DBusError aError;
 123     DBusConnection *pConnection;
 124
 125     dbus_error_init( &aError );
 126
 127     pConnection = dbus_bus_get( DBUS_BUS_SYSTEM, &aError );
 128     if( !pConnection || dbus_error_is_set( &aError ))
 129     {
 130         SAL_WARN( "sdremote.bluetooth", "failed to get dbus system bus: " << aError.message );
 131         dbus_error_free( &aError );
 132         return nullptr;
 133     }
 134
 135     return pConnection;
 136 }
 137
 138 static DBusMessage *
 139 sendUnrefAndWaitForReply( DBusConnection *pConnection, DBusMessage *pMsg )
 140 {
 141     DBusPendingCall *pPending = nullptr;
 142
 143     if( !pMsg || !dbus_connection_send_with_reply( pConnection, pMsg, &pPending,
 144                                                    -1 /* default timeout */ ) )
 145     {
 146         SAL_WARN( "sdremote.bluetooth", "Memory allocation failed on message send" );
 147         dbus_message_unref( pMsg );
 148         return nullptr;
 149     }
 150     dbus_connection_flush( pConnection );
 151     dbus_message_unref( pMsg );
 152
 153     dbus_pending_call_block( pPending ); // block for reply
 154
 155     pMsg = dbus_pending_call_steal_reply( pPending );
 156     if( !pMsg )
 157         SAL_WARN( "sdremote.bluetooth", "no valid reply / timeout" );
 158
 159     dbus_pending_call_unref( pPending );
 160     return pMsg;
 161 }
 162
 163 static bool
 164 isBluez5Available(DBusConnection *pConnection)
 165 {
 166     DBusMessage *pMsg;
 167
 168     // Simplest ways to check whether we have Bluez 5+ is to check
 169     // that we can obtain adapters using the new interfaces.
 170     // The first two error checks however don't tell us anything as they should
 171     // succeed as long as dbus is working correctly.
 172     pMsg = DBusObject( "org.bluez", "/", "org.freedesktop.DBus.ObjectManager" ).getMethodCall( "GetManagedObjects" );
 173     if (!pMsg)
 174     {
 175         SAL_INFO("sdremote.bluetooth", "No GetManagedObjects call created");
 176         return false;
 177     }
 178
 179     pMsg = sendUnrefAndWaitForReply( pConnection, pMsg );
 180     if (!pMsg)
 181     {
 182         SAL_INFO("sdremote.bluetooth", "No reply received");
 183         return false;
 184     }
 185
 186     // If dbus is working correctly and we aren't on bluez 5 this is where we
 187     // should actually get the error.
 188     if (dbus_message_get_error_name( pMsg ))
 189     {
 190         SAL_INFO( "sdremote.bluetooth", "GetManagedObjects call failed with \""
 191                     << dbus_message_get_error_name( pMsg )
 192                     << "\" -- we don't seem to have Bluez 5 available");
 193         return false;
 194     }
 195     SAL_INFO("sdremote.bluetooth", "GetManagedObjects call seems to have succeeded -- we must be on Bluez 5");
 196     dbus_message_unref(pMsg);
 197     return true;
 198 }
 199
 200 static std::unique_ptr<DBusObject>
 201 getBluez5Adapter(DBusConnection *pConnection)
 202 {
 203     DBusMessage *pMsg;
 204     // This returns a list of objects where we need to find the first
 205     // org.bluez.Adapter1 .
 206     pMsg = DBusObject( "org.bluez", "/", "org.freedesktop.DBus.ObjectManager" ).getMethodCall( "GetManagedObjects" );
 207     if (!pMsg)
 208         return nullptr;
 209
 210     const gchar* const pInterfaceType = "org.bluez.Adapter1";
 211
 212     pMsg = sendUnrefAndWaitForReply( pConnection, pMsg );
 213
 214     DBusMessageIter aObjectIterator;
 215     if (pMsg && dbus_message_iter_init(pMsg, &aObjectIterator))
 216     {
 217         if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&aObjectIterator))
 218         {
 219             DBusMessageIter aObject;
 220             dbus_message_iter_recurse(&aObjectIterator, &aObject);
 221             do
 222             {
 223                 if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&aObject))
 224                 {
 225                     DBusMessageIter aContainerIter;
 226                     dbus_message_iter_recurse(&aObject, &aContainerIter);
 227                     char *pPath = nullptr;
 228                     do
 229                     {
 230                         if (DBUS_TYPE_OBJECT_PATH == dbus_message_iter_get_arg_type(&aContainerIter))
 231                         {
 232                             dbus_message_iter_get_basic(&aContainerIter, &pPath);
 233                             SAL_INFO( "sdremote.bluetooth", "Something retrieved: '"
 234                             << pPath << "' '");
 235                         }
 236                         else if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&aContainerIter))
 237                         {
 238                             DBusMessageIter aInnerIter;
 239                             dbus_message_iter_recurse(&aContainerIter, &aInnerIter);
 240                             do
 241                             {
 242                                 if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&aInnerIter))
 243                                 {
 244                                     DBusMessageIter aInnerInnerIter;
 245                                     dbus_message_iter_recurse(&aInnerIter, &aInnerInnerIter);
 246                                     do
 247                                     {
 248                                         if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&aInnerInnerIter))
 249                                         {
 250                                             char* pMessage;
 251
 252                                             dbus_message_iter_get_basic(&aInnerInnerIter, &pMessage);
 253                                             if (OString(pMessage) == "org.bluez.Adapter1")
 254                                             {
 255                                                 dbus_message_unref(pMsg);
 256                                                 if (pPath)
 257                                                 {
 258                                                     return std::make_unique<DBusObject>( "org.bluez", pPath, pInterfaceType );
 259                                                 }
 260                                                 assert(false); // We should already have pPath provided for us.
 261                                             }
 262                                         }
 263                                     }
 264                                     while (dbus_message_iter_next(&aInnerInnerIter));
 265                                 }
 266                             }
 267                             while (dbus_message_iter_next(&aInnerIter));
 268                         }
 269                     }
 270                     while (dbus_message_iter_next(&aContainerIter));
 271                 }
 272             }
 273             while (dbus_message_iter_next(&aObject));
 274         }
 275         dbus_message_unref(pMsg);
 276     }
 277
 278     return nullptr;
 279 }
 280
 281 static DBusObject *
 282 bluez4GetDefaultService( DBusConnection *pConnection )
 283 {
 284     DBusMessage *pMsg;
 285     DBusMessageIter it;
 286     const gchar* const pInterfaceType = "org.bluez.Service";
 287
 288     // org.bluez.manager only exists for bluez 4.
 289     // getMethodCall should return NULL if there is any issue e.g. the
 290     // if org.bluez.manager doesn't exist.
 291     pMsg = DBusObject( "org.bluez", "/", "org.bluez.Manager" ).getMethodCall( "DefaultAdapter" );
 292
 293     if (!pMsg)
 294     {
 295         SAL_WARN("sdremote.bluetooth", "Couldn't retrieve DBusObject for DefaultAdapter");
 296         return nullptr;
 297     }
 298
 299     SAL_INFO("sdremote.bluetooth", "successfully retrieved org.bluez.Manager.DefaultAdapter, attempting to use.");
 300     pMsg = sendUnrefAndWaitForReply( pConnection, pMsg );
 301
 302     if(!pMsg || !dbus_message_iter_init( pMsg, &it ) )
 303     {
 304         return nullptr;
 305     }
 306
 307     // This works for Bluez 4
 308     if( DBUS_TYPE_OBJECT_PATH == dbus_message_iter_get_arg_type( &it ) )
 309     {
 310         const char *pObjectPath = nullptr;
 311         dbus_message_iter_get_basic( &it, &pObjectPath );
 312         SAL_INFO( "sdremote.bluetooth", "DefaultAdapter retrieved: '"
 313                 << pObjectPath << "' '" << pInterfaceType << "'" );
 314         dbus_message_unref( pMsg );
 315         return new DBusObject( "org.bluez", pObjectPath, pInterfaceType );
 316     }
 317     // Some form of error, e.g. if we have bluez 5 we get a message that
 318     // this method doesn't exist.
 319     else if ( DBUS_TYPE_STRING == dbus_message_iter_get_arg_type( &it ) )
 320     {
 321         const char *pMessage = nullptr;
 322         dbus_message_iter_get_basic( &it, &pMessage );
 323         SAL_INFO( "sdremote.bluetooth", "Error message: '"
 324                 << pMessage << "' '" << pInterfaceType << "'" );
 325     }
 326     else
 327     {
 328         SAL_INFO( "sdremote.bluetooth", "invalid type of reply to DefaultAdapter: '"
 329                 << static_cast<char>(dbus_message_iter_get_arg_type( &it )) << "'" );
 330     }
 331     dbus_message_unref(pMsg);
 332     return nullptr;
 333 }
 334
 335 static bool
 336 bluez4RegisterServiceRecord( DBusConnection *pConnection, DBusObject *pAdapter,
 337                             const char *pServiceRecord )
 338 {
 339     DBusMessage *pMsg;
 340     DBusMessageIter it;
 341
 342     pMsg = pAdapter->getMethodCall( "AddRecord" );
 343     dbus_message_iter_init_append( pMsg, &it );
 344     dbus_message_iter_append_basic( &it, DBUS_TYPE_STRING, &pServiceRecord );
 345
 346     pMsg = sendUnrefAndWaitForReply( pConnection, pMsg );
 347
 348     if( !pMsg || !dbus_message_iter_init( pMsg, &it ) ||
 349         dbus_message_iter_get_arg_type( &it ) != DBUS_TYPE_UINT32 )
 350     {
 351         SAL_WARN( "sdremote.bluetooth", "SDP registration failed" );
 352         return false;
 353     }
 354
 355     // We ignore the uint de-registration handle we get back:
 356     // bluez will clean us up automatically on exit
 357
 358     return true;
 359 }
 360
 361 static void
 362 bluezCreateAttachListeningSocket( GMainContext *pContext, GPollFD *pSocketFD )
 363 {
 364     int nSocket;
 365
 366     pSocketFD->fd = -1;
 367
 368     if( ( nSocket = socket( AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM ) ) < 0 )
 369     {
 370         SAL_WARN( "sdremote.bluetooth", "failed to open bluetooth socket with error " << nSocket );
 371         return;
 372     }
 373
 374     sockaddr_rc aAddr;
 375     // Initialize whole structure. Mainly to appease valgrind, which
 376     // doesn't know about the padding at the end of sockaddr_rc which
 377     // it will dutifully check for definedness. But also the standard
 378     // definition of BDADDR_ANY is unusable in C++ code, so just use
 379     // memset to set aAddr.rc_bdaddr to 0.
 380     memset( &aAddr, 0, sizeof( aAddr ) );
 381     aAddr.rc_family = AF_BLUETOOTH;
 382     aAddr.rc_channel = 5;
 383
 384     int a;
 385     if ( ( a = bind( nSocket, reinterpret_cast<sockaddr*>(&aAddr), sizeof(aAddr) ) ) < 0 ) {
 386         SAL_WARN( "sdremote.bluetooth", "bind failed with error" << a );
 387         close( nSocket );
 388         return;
 389     }
 390
 391     if ( ( a = listen( nSocket, 1 ) ) < 0 )
 392     {
 393         SAL_WARN( "sdremote.bluetooth", "listen failed with error" << a );
 394         close( nSocket );
 395         return;
 396     }
 397
 398     // set non-blocking behaviour ...
 399     if( fcntl( nSocket, F_SETFL, O_NONBLOCK) < 0 )
 400     {
 401         close( nSocket );
 402         return;
 403     }
 404
 405     pSocketFD->fd = nSocket;
 406     pSocketFD->events = G_IO_IN | G_IO_PRI;
 407     pSocketFD->revents = 0;
 408
 409     g_main_context_add_poll( pContext, pSocketFD, G_PRIORITY_DEFAULT );
 410 }
 411
 412 static void
 413 bluezDetachCloseSocket( GMainContext *pContext, GPollFD *pSocketFD )
 414 {
 415     if( pSocketFD->fd >= 0 )
 416     {
 417         close( pSocketFD->fd );
 418         g_main_context_remove_poll( pContext, pSocketFD );
 419         pSocketFD->fd = -1;
 420     }
 421 }
 422
 423 #endif // LINUX_BLUETOOTH
 424
 425 #if defined(MACOSX)
 426
 427 OSXBluetoothWrapper::OSXBluetoothWrapper( IOBluetoothRFCOMMChannel* channel ) :
 428     mpChannel(channel),
 429     mnMTU(0),
 430     mHaveBytes(),
 431     mMutex(),
 432     mBuffer()
 433 {
 434     // silly enough, can't write more than mnMTU bytes at once
 435     mnMTU = [channel getMTU];
 436
 437     SAL_INFO( "sdremote.bluetooth", "OSXBluetoothWrapper::OSXBluetoothWrapper(): mnMTU=" << mnMTU );
 438 }
 439
 440 sal_Int32 OSXBluetoothWrapper::readLine( OString& aLine )
 441 {
 442     SAL_INFO( "sdremote.bluetooth", "OSXBluetoothWrapper::readLine()" );
 443
 444     while( true )
 445     {
 446         {
 447             SAL_INFO( "sdremote.bluetooth", "OSXBluetoothWrapper::readLine: entering mutex" );
 448             ::osl::MutexGuard aQueueGuard( mMutex );
 449             SAL_INFO( "sdremote.bluetooth", "OSXBluetoothWrapper::readLine: entered mutex" );
 450
 451 #ifdef SAL_LOG_INFO
 452             // We should have in the sal logging some standard way to
 453             // output char buffers with non-printables escaped.
 454             std::ostringstream s;
 455             if (mBuffer.size() > 0)
 456             {
 457                 for (unsigned char *p = reinterpret_cast<unsigned char *>(mBuffer.data()); p != reinterpret_cast<unsigned char *>(mBuffer.data()) + mBuffer.size(); p++)
 458                 {
 459                     if (*p == '\n')
 460                         s << "\\n";
 461                     else if (*p < ' ' || *p >= 0x7F)
 462                         s << "\\0x" << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(*p) << std::setfill(' ') << std::setw(1) << std::dec;
 463                     else
 464                         s << *p;
 465                 }
 466             }
 467             SAL_INFO( "sdremote.bluetooth", "OSXBluetoothWrapper::readLine mBuffer:  \"" << s.str() << "\"" );
 468 #endif
 469
 470             // got enough bytes to return a line?
 471             std::vector<char>::iterator aIt;
 472             if ( (aIt = find( mBuffer.begin(), mBuffer.end(), '\n' ))
 473                  != mBuffer.end() )
 474             {
 475                 sal_uInt64 aLocation = aIt - mBuffer.begin();
 476
 477                 aLine = OString( &(*mBuffer.begin()), aLocation );
 478
 479                 mBuffer.erase( mBuffer.begin(), aIt + 1 ); // Also delete the empty line
 480
 481                 // yeps
 482                 SAL_INFO( "sdremote.bluetooth", "  returning, got \"" << OStringToOUString( aLine, RTL_TEXTENCODING_UTF8 ) << "\"" );
 483                 return aLine.getLength() + 1;
 484             }
 485
 486             // nope - wait some more (after releasing the mutex)
 487             SAL_INFO( "sdremote.bluetooth", "  resetting mHaveBytes" );
 488             mHaveBytes.reset();
 489             SAL_INFO( "sdremote.bluetooth", "  leaving mutex" );
 490         }
 491
 492         SAL_INFO( "sdremote.bluetooth", "  waiting for mHaveBytes" );
 493         mHaveBytes.wait();
 494         SAL_INFO( "sdremote.bluetooth", "OSXBluetoothWrapper::readLine: got mHaveBytes" );
 495     }
 496 }
 497
 498 sal_Int32 OSXBluetoothWrapper::write( const void* pBuffer, sal_uInt32 n )
 499 {
 500     SAL_INFO( "sdremote.bluetooth", "OSXBluetoothWrapper::write(" << pBuffer << ", " << n << ") mpChannel=" << mpChannel );
 501
 502     char const * ptr = static_cast<char const *>(pBuffer);
 503     sal_uInt32 nBytesWritten = 0;
 504
 505     if (mpChannel == nil)
 506         return 0;
 507
 508     while( nBytesWritten < n )
 509     {
 510         int toWrite = n - nBytesWritten;
 511         toWrite = toWrite <= mnMTU ? toWrite : mnMTU;
 512         if ( [mpChannel writeSync:const_cast<char *>(ptr) length:toWrite] != kIOReturnSuccess )
 513         {
 514             SAL_INFO( "sdremote.bluetooth", "  [mpChannel writeSync:" << static_cast<void const *>(ptr) << " length:" << toWrite << "] returned error, total written " << nBytesWritten );
 515             return nBytesWritten;
 516         }
 517         ptr += toWrite;
 518         nBytesWritten += toWrite;
 519     }
 520     SAL_INFO( "sdremote.bluetooth", "  total written " << nBytesWritten );
 521     return nBytesWritten;
 522 }
 523
 524 void OSXBluetoothWrapper::appendData(void* pBuffer, size_t len)
 525 {
 526     SAL_INFO( "sdremote.bluetooth", "OSXBluetoothWrapper::appendData(" << pBuffer << ", " << len << ")" );
 527
 528     if( len )
 529     {
 530         SAL_INFO( "sdremote.bluetooth", "OSXBluetoothWrapper::appendData: entering mutex" );
 531         ::osl::MutexGuard aQueueGuard( mMutex );
 532         SAL_INFO( "sdremote.bluetooth", "OSXBluetoothWrapper::appendData: entered mutex" );
 533         mBuffer.insert(mBuffer.begin()+mBuffer.size(),
 534                        static_cast<char*>(pBuffer), static_cast<char *>(pBuffer)+len);
 535         SAL_INFO( "sdremote.bluetooth", "  setting mHaveBytes" );
 536         mHaveBytes.set();
 537         SAL_INFO( "sdremote.bluetooth", "  leaving mutex" );
 538     }
 539 }
 540
 541 void OSXBluetoothWrapper::channelClosed()
 542 {
 543     SAL_INFO( "sdremote.bluetooth", "OSXBluetoothWrapper::channelClosed()" );
 544
 545     mpChannel = nil;
 546 }
 547
 548 void incomingCallback( void *userRefCon,
 549                        IOBluetoothUserNotificationRef,
 550                        IOBluetoothObjectRef objectRef )
 551 {
 552     SAL_INFO( "sdremote.bluetooth", "incomingCallback()" );
 553
 554     BluetoothServer* pServer = static_cast<BluetoothServer*>(userRefCon);
 555
 556     IOBluetoothRFCOMMChannel* channel = [IOBluetoothRFCOMMChannel withRFCOMMChannelRef:reinterpret_cast<IOBluetoothRFCOMMChannelRef>(objectRef)];
 557
 558     OSXBluetoothWrapper* socket = new OSXBluetoothWrapper( channel);
 559     Communicator* pCommunicator = new Communicator( std::unique_ptr<IBluetoothSocket>(socket) );
 560     pServer->addCommunicator( pCommunicator );
 561
 562     ChannelDelegate* delegate = [[ChannelDelegate alloc] initWithCommunicatorAndSocket: pCommunicator socket: socket];
 563     [channel setDelegate: delegate];
 564     [delegate retain];
 565
 566     pCommunicator->launch();
 567 }
 568
 569 void BluetoothServer::addCommunicator( Communicator* pCommunicator )
 570 {
 571     mpCommunicators->push_back( pCommunicator );
 572 }
 573
 574 #endif // MACOSX
 575
 576 #ifdef LINUX_BLUETOOTH
 577
 578 extern "C" {
 579     static gboolean ensureDiscoverable_cb(gpointer)
 580     {
 581         BluetoothServer::doEnsureDiscoverable();
 582         return FALSE; // remove source
 583     }
 584     static gboolean restoreDiscoverable_cb(gpointer)
 585     {
 586         BluetoothServer::doRestoreDiscoverable();
 587         return FALSE; // remove source
 588     }
 589 }
 590
 591 /*
 592  * Bluez 4 uses custom methods for setting properties, whereas Bluez 5+
 593  * implements properties using the generic "org.freedesktop.DBus.Properties"
 594  * interface -- hence we have a specific Bluez 4 function to deal with the
 595  * old style of reading properties.
 596  */
 597 static bool
 598 getBluez4BooleanProperty( DBusConnection *pConnection, DBusObject *pAdapter,
 599                     const char *pPropertyName, bool *pBoolean )
 600 {
 601     *pBoolean = false;
 602
 603     if( !pAdapter )
 604         return false;
 605
 606     DBusMessage *pMsg;
 607     pMsg = sendUnrefAndWaitForReply( pConnection,
 608                                      pAdapter->getMethodCall( "GetProperties" ) );
 609
 610     DBusMessageIter it;
 611     if( !pMsg || !dbus_message_iter_init( pMsg, &it ) )
 612     {
 613         SAL_WARN( "sdremote.bluetooth", "no valid reply / timeout" );
 614         return false;
 615     }
 616
 617     if( DBUS_TYPE_ARRAY != dbus_message_iter_get_arg_type( &it ) )
 618     {
 619         SAL_WARN( "sdremote.bluetooth", "no valid reply / timeout" );
 620         return false;
 621     }
 622
 623     DBusMessageIter arrayIt;
 624     dbus_message_iter_recurse( &it, &arrayIt );
 625
 626     while( dbus_message_iter_get_arg_type( &arrayIt ) == DBUS_TYPE_DICT_ENTRY )
 627     {
 628         DBusMessageIter dictIt;
 629         dbus_message_iter_recurse( &arrayIt, &dictIt );
 630
 631         const char *pName = nullptr;
 632         if( dbus_message_iter_get_arg_type( &dictIt ) == DBUS_TYPE_STRING )
 633         {
 634             dbus_message_iter_get_basic( &dictIt, &pName );
 635             if( pName != nullptr && !strcmp( pName, pPropertyName ) )
 636             {
 637                 SAL_INFO( "sdremote.bluetooth", "hit " << pPropertyName << " property" );
 638                 dbus_message_iter_next( &dictIt );
 639                 dbus_bool_t bBool = false;
 640
 641                 if( dbus_message_iter_get_arg_type( &dictIt ) == DBUS_TYPE_VARIANT )
 642                 {
 643                     DBusMessageIter variantIt;
 644                     dbus_message_iter_recurse( &dictIt, &variantIt );
 645
 646                     if( dbus_message_iter_get_arg_type( &variantIt ) == DBUS_TYPE_BOOLEAN )
 647                     {
 648                         dbus_message_iter_get_basic( &variantIt, &bBool );
 649                         SAL_INFO( "sdremote.bluetooth", "" << pPropertyName << " is " << bBool );
 650                         *pBoolean = bBool;
 651                         return true;
 652                     }
 653                     else
 654                         SAL_WARN( "sdremote.bluetooth", "" << pPropertyName << " type " <<
 655                                   dbus_message_iter_get_arg_type( &variantIt ) );
 656                 }
 657                 else
 658                     SAL_WARN( "sdremote.bluetooth", "variant type ? " <<
 659                               dbus_message_iter_get_arg_type( &dictIt ) );
 660             }
 661             else
 662             {
 663                 const char *pStr = pName ? pName : "<null>";
 664                 SAL_INFO( "sdremote.bluetooth", "property '" << pStr << "'" );
 665             }
 666         }
 667         else
 668             SAL_WARN( "sdremote.bluetooth", "unexpected property key type "
 669                       << dbus_message_iter_get_arg_type( &dictIt ) );
 670         dbus_message_iter_next( &arrayIt );
 671     }
 672     dbus_message_unref( pMsg );
 673
 674     return false;
 675 }
 676
 677 /*
 678  * This gets an org.freedesktop.DBus.Properties boolean
 679  * (as opposed to the old Bluez 4 custom properties methods as visible above).
 680  */
 681 static bool
 682 getDBusBooleanProperty( DBusConnection *pConnection, DBusObject *pAdapter,
 683                         const char *pPropertyName, bool *pBoolean )
 684 {
 685     assert( pAdapter );
 686
 687     *pBoolean = false;
 688     bool bRet = false;
 689
 690     std::unique_ptr< DBusObject > pProperties (
 691             pAdapter->cloneForInterface( "org.freedesktop.DBus.Properties" ) );
 692
 693     DBusMessage *pMsg = pProperties->getMethodCall( "Get" );
 694
 695     DBusMessageIter itIn;
 696     dbus_message_iter_init_append( pMsg, &itIn );
 697     const char* pInterface = "org.bluez.Adapter1";
 698     dbus_message_iter_append_basic( &itIn, DBUS_TYPE_STRING, &pInterface );
 699     dbus_message_iter_append_basic( &itIn, DBUS_TYPE_STRING, &pPropertyName );
 700     pMsg = sendUnrefAndWaitForReply( pConnection, pMsg );
 701
 702     DBusMessageIter it;
 703     if( !pMsg || !dbus_message_iter_init( pMsg, &it ) )
 704     {
 705         SAL_WARN( "sdremote.bluetooth", "no valid reply / timeout" );
 706         return false;
 707     }
 708
 709     if( DBUS_TYPE_VARIANT != dbus_message_iter_get_arg_type( &it ) )
 710     {
 711         SAL_WARN( "sdremote.bluetooth", "invalid return type" );
 712     }
 713     else
 714     {
 715         DBusMessageIter variantIt;
 716         dbus_message_iter_recurse( &it, &variantIt );
 717
 718         if( dbus_message_iter_get_arg_type( &variantIt ) == DBUS_TYPE_BOOLEAN )
 719         {
 720             dbus_bool_t bBool = false;
 721             dbus_message_iter_get_basic( &variantIt, &bBool );
 722             SAL_INFO( "sdremote.bluetooth", "" << pPropertyName << " is " << bBool );
 723             *pBoolean = bBool;
 724             bRet = true;
 725         }
 726         else
 727         {
 728             SAL_WARN( "sdremote.bluetooth", "" << pPropertyName << " type " <<
 729                         dbus_message_iter_get_arg_type( &variantIt ) );
 730         }
 731
 732         const char* pError = dbus_message_get_error_name( pMsg );
 733         if ( pError )
 734         {
 735             SAL_WARN( "sdremote.bluetooth",
 736                       "Get failed for " << pPropertyName << " on " <<
 737                       pAdapter->maPath  << " with error: " << pError );
 738         }
 739     }
 740     dbus_message_unref( pMsg );
 741
 742     return bRet;
 743 }
 744
 745 static void
 746 setDBusBooleanProperty( DBusConnection *pConnection, DBusObject *pAdapter,
 747                         const char *pPropertyName, bool bBoolean )
 748 {
 749     assert( pAdapter );
 750
 751     std::unique_ptr< DBusObject > pProperties(
 752             pAdapter->cloneForInterface( "org.freedesktop.DBus.Properties" ) );
 753
 754     DBusMessage *pMsg = pProperties->getMethodCall( "Set" );
 755
 756     DBusMessageIter itIn;
 757     dbus_message_iter_init_append( pMsg, &itIn );
 758     const char* pInterface = "org.bluez.Adapter1";
 759     dbus_message_iter_append_basic( &itIn, DBUS_TYPE_STRING, &pInterface );
 760     dbus_message_iter_append_basic( &itIn, DBUS_TYPE_STRING, &pPropertyName );
 761
 762     {
 763         DBusMessageIter varIt;
 764         dbus_message_iter_open_container( &itIn, DBUS_TYPE_VARIANT,
 765                                         DBUS_TYPE_BOOLEAN_AS_STRING, &varIt );
 766         dbus_bool_t bDBusBoolean = bBoolean;
 767         dbus_message_iter_append_basic( &varIt, DBUS_TYPE_BOOLEAN, &bDBusBoolean );
 768         dbus_message_iter_close_container( &itIn, &varIt );
 769     }
 770
 771     pMsg = sendUnrefAndWaitForReply( pConnection, pMsg );
 772
 773     if( !pMsg )
 774     {
 775         SAL_WARN( "sdremote.bluetooth", "no valid reply / timeout" );
 776     }
 777     else
 778     {
 779         const char* pError = dbus_message_get_error_name( pMsg );
 780         if ( pError )
 781         {
 782             SAL_WARN( "sdremote.bluetooth",
 783                       "Set failed for " << pPropertyName << " on " <<
 784                       pAdapter->maPath << " with error: " << pError );
 785         }
 786         dbus_message_unref( pMsg );
 787     }
 788 }
 789
 790 static bool
 791 getDiscoverable( DBusConnection *pConnection, DBusObject *pAdapter )
 792 {
 793     if (pAdapter->maInterface == "org.bluez.Adapter") // Bluez 4
 794     {
 795         bool bDiscoverable;
 796         if( getBluez4BooleanProperty(pConnection, pAdapter, "Discoverable", &bDiscoverable ) )
 797             return bDiscoverable;
 798     }
 799     else if (pAdapter->maInterface == "org.bluez.Adapter1") // Bluez 5
 800     {
 801         bool bDiscoverable;
 802         if ( getDBusBooleanProperty(pConnection, pAdapter, "Discoverable", &bDiscoverable ) )
 803             return bDiscoverable;
 804     }
 805     return false;
 806 }
 807
 808 static void
 809 setDiscoverable( DBusConnection *pConnection, DBusObject *pAdapter, bool bDiscoverable )
 810 {
 811     SAL_INFO( "sdremote.bluetooth", "setDiscoverable to " << bDiscoverable );
 812
 813     if (pAdapter->maInterface == "org.bluez.Adapter") // Bluez 4
 814     {
 815         bool bPowered = false;
 816         if( !getBluez4BooleanProperty( pConnection, pAdapter, "Powered", &bPowered ) || !bPowered )
 817             return; // nothing to do
 818
 819         DBusMessage *pMsg;
 820         DBusMessageIter it, varIt;
 821
 822         // set timeout to zero
 823         pMsg = pAdapter->getMethodCall( "SetProperty" );
 824         dbus_message_iter_init_append( pMsg, &it );
 825         const char *pTimeoutStr = "DiscoverableTimeout";
 826         dbus_message_iter_append_basic( &it, DBUS_TYPE_STRING, &pTimeoutStr );
 827         dbus_message_iter_open_container( &it, DBUS_TYPE_VARIANT,
 828                                         DBUS_TYPE_UINT32_AS_STRING, &varIt );
 829         dbus_uint32_t nTimeout = 0;
 830         dbus_message_iter_append_basic( &varIt, DBUS_TYPE_UINT32, &nTimeout );
 831         dbus_message_iter_close_container( &it, &varIt );
 832         dbus_connection_send( pConnection, pMsg, nullptr ); // async send - why not ?
 833         dbus_message_unref( pMsg );
 834
 835         // set discoverable value
 836         pMsg = pAdapter->getMethodCall( "SetProperty" );
 837         dbus_message_iter_init_append( pMsg, &it );
 838         const char *pDiscoverableStr = "Discoverable";
 839         dbus_message_iter_append_basic( &it, DBUS_TYPE_STRING, &pDiscoverableStr );
 840         dbus_message_iter_open_container( &it, DBUS_TYPE_VARIANT,
 841                                         DBUS_TYPE_BOOLEAN_AS_STRING, &varIt );
 842         dbus_bool_t bValue = bDiscoverable;
 843         dbus_message_iter_append_basic( &varIt, DBUS_TYPE_BOOLEAN, &bValue );
 844         dbus_message_iter_close_container( &it, &varIt ); // async send - why not ?
 845         dbus_connection_send( pConnection, pMsg, nullptr );
 846         dbus_message_unref( pMsg );
 847     }
 848     else if  (pAdapter->maInterface == "org.bluez.Adapter1") // Bluez 5
 849     {
 850         setDBusBooleanProperty(pConnection, pAdapter, "Discoverable", bDiscoverable );
 851     }
 852 }
 853
 854 static std::unique_ptr<DBusObject>
 855 registerWithDefaultAdapter( DBusConnection *pConnection )
 856 {
 857     std::unique_ptr<DBusObject> pService(bluez4GetDefaultService( pConnection ));
 858     if( pService )
 859     {
 860         if( !bluez4RegisterServiceRecord( pConnection, pService.get(),
 861                                      bluetooth_service_record ) )
 862         {
 863             return nullptr;
 864         }
 865     }
 866
 867     return pService;
 868 }
 869
 870 static void ProfileUnregisterFunction
 871 (DBusConnection *, void *)
 872 {
 873     // We specifically don't need to do anything here.
 874 }
 875
 876 static DBusHandlerResult ProfileMessageFunction
 877 (DBusConnection *pConnection, DBusMessage *pMessage, void *user_data)
 878 {
 879     SAL_INFO("sdremote.bluetooth", "ProfileMessageFunction||" << dbus_message_get_interface(pMessage) << "||" <<  dbus_message_get_member(pMessage));
 880
 881     if (OString(dbus_message_get_interface(pMessage)) == "org.bluez.Profile1")
 882     {
 883         if (OString(dbus_message_get_member(pMessage)) == "Release")
 884         {
 885             return DBUS_HANDLER_RESULT_HANDLED;
 886         }
 887         else if (OString(dbus_message_get_member(pMessage)) == "NewConnection")
 888         {
 889             if (!dbus_message_has_signature(pMessage, "oha{sv}"))
 890             {
 891                 SAL_WARN("sdremote.bluetooth", "wrong signature for NewConnection");
 892             }
 893
 894             DBusMessageIter it;
 895             if (!dbus_message_iter_init(pMessage, &it))
 896                 SAL_WARN( "sdremote.bluetooth", "error init dbus" );
 897             else
 898             {
 899                 char* pPath;
 900                 dbus_message_iter_get_basic(&it, &pPath);
 901                 SAL_INFO("sdremote.bluetooth", "Adapter path:" << pPath);
 902
 903                 if (!dbus_message_iter_next(&it))
 904                     SAL_WARN("sdremote.bluetooth", "not enough parameters passed");
 905
 906                 // DBUS_TYPE_UNIX_FD == 'h' -- doesn't exist in older versions
 907                 // of dbus (< 1.3?) hence defined manually for now
 908                 if ('h' == dbus_message_iter_get_arg_type(&it))
 909                 {
 910
 911                     int nDescriptor;
 912                     dbus_message_iter_get_basic(&it, &nDescriptor);
 913                     std::vector<Communicator*>* pCommunicators = static_cast<std::vector<Communicator*>*>(user_data);
 914
 915                     // Bluez gives us non-blocking sockets, but our code relies
 916                     // on blocking behaviour.
 917                     (void)fcntl(nDescriptor, F_SETFL, fcntl(nDescriptor, F_GETFL) & ~O_NONBLOCK);
 918
 919                     SAL_INFO( "sdremote.bluetooth", "connection accepted " << nDescriptor);
 920                     Communicator* pCommunicator = new Communicator( std::make_unique<BufferedStreamSocket>( nDescriptor ) );
 921                     pCommunicators->push_back( pCommunicator );
 922                     pCommunicator->launch();
 923                 }
 924
 925                 // For some reason an (empty?) reply is expected.
 926                 DBusMessage* pRet = dbus_message_new_method_return(pMessage);
 927                 dbus_connection_send(pConnection, pRet, nullptr);
 928                 dbus_message_unref(pRet);
 929
 930                 // We could read the remote profile version and features here
 931                 // (i.e. they are provided as part of the DBusMessage),
 932                 // however for us they are irrelevant (as our protocol handles
 933                 // equivalent functionality independently of whether we're on
 934                 // bluetooth or normal network connection).
 935                 return DBUS_HANDLER_RESULT_HANDLED;
 936             }
 937         }
 938         else if (OString(dbus_message_get_member(pMessage)) == "RequestDisconnection")
 939         {
 940             return DBUS_HANDLER_RESULT_HANDLED;
 941         }
 942     }
 943     SAL_WARN("sdremote.bluetooth", "Couldn't handle message correctly.");
 944     return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 945
 946 }
 947
 948 static void
 949 setupBluez5Profile1(DBusConnection* pConnection, std::vector<Communicator*>* pCommunicators)
 950 {
 951     bool bErr;
 952
 953     SAL_INFO("sdremote.bluetooth", "Attempting to register our org.bluez.Profile1");
 954     static DBusObjectPathVTable aVTable;
 955     aVTable.unregister_function = ProfileUnregisterFunction;
 956     aVTable.message_function = ProfileMessageFunction;
 957
 958     // dbus_connection_try_register_object_path could be used but only exists for
 959     // dbus >= 1.2 -- we really shouldn't be trying this twice in any case.
 960     // (dbus_connection_try_register_object_path also returns an error with more
 961     // information which could be useful for debugging purposes.)
 962     bErr = !dbus_connection_register_object_path(pConnection, "/org/libreoffice/bluez/profile1", &aVTable, pCommunicators);
 963
 964     if (bErr)
 965     {
 966         SAL_WARN("sdremote.bluetooth", "Failed to register Bluez 5 Profile1 callback, bluetooth won't work.");
 967     }
 968
 969     dbus_connection_flush( pConnection );
 970 }
 971
 972 static void
 973 unregisterBluez5Profile(DBusConnection* pConnection)
 974 {
 975     DBusMessage* pMsg = dbus_message_new_method_call("org.bluez", "/org/bluez",
 976                                         "org.bluez.ProfileManager1", "UnregisterProfile");
 977     DBusMessageIter it;
 978     dbus_message_iter_init_append(pMsg, &it);
 979
 980     const char *pPath = "/org/libreoffice/bluez/profile1";
 981     dbus_message_iter_append_basic(&it, DBUS_TYPE_OBJECT_PATH, &pPath);
 982
 983     pMsg = sendUnrefAndWaitForReply( pConnection, pMsg );
 984
 985     if (pMsg)
 986         dbus_message_unref(pMsg);
 987
 988     dbus_connection_unregister_object_path( pConnection, "/org/libreoffice/bluez/profile1");
 989
 990     dbus_connection_flush(pConnection);
 991 }
 992
 993 static bool
 994 registerBluez5Profile(DBusConnection* pConnection, std::vector<Communicator*>* pCommunicators)
 995 {
 996     setupBluez5Profile1(pConnection, pCommunicators);
 997
 998     DBusMessage *pMsg;
 999     DBusMessageIter it;
1000
1001     pMsg = dbus_message_new_method_call("org.bluez", "/org/bluez",
1002                                         "org.bluez.ProfileManager1", "RegisterProfile");
1003     dbus_message_iter_init_append(pMsg, &it);
1004
1005     const char *pPath = "/org/libreoffice/bluez/profile1";
1006     dbus_message_iter_append_basic(&it, DBUS_TYPE_OBJECT_PATH, &pPath);
1007     const char *pUUID =  "spp"; // Bluez translates this to 0x1101 for spp
1008     dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &pUUID);
1009
1010     DBusMessageIter aOptionsIter;
1011     dbus_message_iter_open_container(&it, DBUS_TYPE_ARRAY, "{sv}", &aOptionsIter);
1012
1013     DBusMessageIter aEntry;
1014
1015     {
1016         dbus_message_iter_open_container(&aOptionsIter, DBUS_TYPE_DICT_ENTRY, nullptr, &aEntry);
1017
1018         const char *pString = "Name";
1019         dbus_message_iter_append_basic(&aEntry, DBUS_TYPE_STRING, &pString);
1020
1021         const char *pValue = "LibreOffice Impress Remote";
1022         DBusMessageIter aValue;
1023         dbus_message_iter_open_container(&aEntry, DBUS_TYPE_VARIANT, "s", &aValue);
1024         dbus_message_iter_append_basic(&aValue, DBUS_TYPE_STRING, &pValue);
1025         dbus_message_iter_close_container(&aEntry, &aValue);
1026         dbus_message_iter_close_container(&aOptionsIter, &aEntry);
1027     }
1028
1029     dbus_message_iter_close_container(&it, &aOptionsIter);
1030
1031     // Other properties that we could set (but don't, since they appear
1032     // to be useless for us):
1033     // "Service": "0x1101" (not needed, but we used to have it in the manually defined profile).
1034     // "Role": setting this to "server" breaks things, although we think we're a server?
1035     // "Channel": seems to be dealt with automatically (but we used to use 5 in the manual profile).
1036
1037     bool bSuccess = true;
1038
1039     pMsg = sendUnrefAndWaitForReply( pConnection, pMsg );
1040
1041     DBusError aError;
1042     dbus_error_init(&aError);
1043     if (pMsg && dbus_set_error_from_message( &aError, pMsg ))
1044     {
1045         bSuccess = false;
1046         SAL_WARN("sdremote.bluetooth",
1047                  "Failed to register our Profile1 with bluez ProfileManager "
1048                  << (aError.message ? aError.message : "<null>"));
1049     }
1050
1051     dbus_error_free(&aError);
1052     if (pMsg)
1053         dbus_message_unref(pMsg);
1054
1055     dbus_connection_flush(pConnection);
1056
1057     return bSuccess;
1058 }
1059
1060 #endif // LINUX_BLUETOOTH
1061
1062 BluetoothServer::BluetoothServer( std::vector<Communicator*>* pCommunicators )
1063   : meWasDiscoverable( UNKNOWN ),
1064     mpCommunicators( pCommunicators )
1065 {
1066 #ifdef LINUX_BLUETOOTH
1067     // D-Bus requires the following in order to be thread-safe (and we
1068     // potentially access D-Bus from different threads in different places of
1069     // the code base):
1070     if (!dbus_threads_init_default()) {
1071         throw std::bad_alloc();
1072     }
1073
1074     mpImpl.reset(new BluetoothServer::Impl());
1075 #endif
1076 }
1077
1078 BluetoothServer::~BluetoothServer()
1079 {
1080 }
1081
1082 void BluetoothServer::ensureDiscoverable()
1083 {
1084 #ifdef LINUX_BLUETOOTH
1085     // Push it all across into our mainloop
1086     if( !spServer )
1087         return;
1088     GSource *pIdle = g_idle_source_new();
1089     g_source_set_callback( pIdle, ensureDiscoverable_cb, nullptr, nullptr );
1090     g_source_set_priority( pIdle, G_PRIORITY_DEFAULT );
1091     g_source_attach( pIdle, spServer->mpImpl->mpContext );
1092     g_source_unref( pIdle );
1093 #endif
1094 }
1095
1096 void BluetoothServer::restoreDiscoverable()
1097 {
1098 #ifdef LINUX_BLUETOOTH
1099     // Push it all across into our mainloop
1100     if( !spServer )
1101         return;
1102     GSource *pIdle = g_idle_source_new();
1103     g_source_set_callback( pIdle, restoreDiscoverable_cb, nullptr, nullptr );
1104     g_source_set_priority( pIdle, G_PRIORITY_DEFAULT_IDLE );
1105     g_source_attach( pIdle, spServer->mpImpl->mpContext );
1106     g_source_unref( pIdle );
1107 #endif
1108 }
1109
1110 void BluetoothServer::doEnsureDiscoverable()
1111 {
1112 #ifdef LINUX_BLUETOOTH
1113     if (!spServer->mpImpl->mpConnection ||
1114         spServer->meWasDiscoverable != UNKNOWN )
1115         return;
1116
1117     // Find out if we are discoverable already ...
1118     std::unique_ptr<DBusObject> pAdapter = spServer->mpImpl->getAdapter();
1119     if( !pAdapter )
1120         return;
1121
1122     bool bDiscoverable = getDiscoverable(spServer->mpImpl->mpConnection, pAdapter.get() );
1123
1124     spServer->meWasDiscoverable = bDiscoverable ? DISCOVERABLE : NOT_DISCOVERABLE;
1125     if( !bDiscoverable )
1126         setDiscoverable( spServer->mpImpl->mpConnection, pAdapter.get(), true );
1127 #endif
1128 }
1129
1130 void BluetoothServer::doRestoreDiscoverable()
1131 {
1132     if( spServer->meWasDiscoverable == NOT_DISCOVERABLE )
1133     {
1134 #ifdef LINUX_BLUETOOTH
1135         std::unique_ptr<DBusObject> pAdapter = spServer->mpImpl->getAdapter();
1136         if( !pAdapter )
1137             return;
1138         setDiscoverable( spServer->mpImpl->mpConnection, pAdapter.get(), false );
1139 #endif
1140     }
1141     spServer->meWasDiscoverable = UNKNOWN;
1142 }
1143
1144 // We have to have all our clients shut otherwise we can't
1145 // re-bind to the same port number it appears.
1146 void BluetoothServer::cleanupCommunicators()
1147 {
1148     for (auto& rpCommunicator : *mpCommunicators)
1149         rpCommunicator->forceClose();
1150     // the hope is that all the threads then terminate cleanly and
1151     // clean themselves up.
1152 }
1153
1154 void SAL_CALL BluetoothServer::run()
1155 {
1156     SAL_INFO( "sdremote.bluetooth", "BluetoothServer::run called" );
1157     osl::Thread::setName("BluetoothServer");
1158 #ifdef LINUX_BLUETOOTH
1159     DBusConnection *pConnection = dbusConnectToNameOnBus();
1160     if( !pConnection )
1161         return;
1162
1163     // For either implementation we need to poll the dbus fd
1164     int fd = -1;
1165     GPollFD aDBusFD;
1166     if( dbus_connection_get_unix_fd( pConnection, &fd ) && fd >= 0 )
1167     {
1168         aDBusFD.fd = fd;
1169         aDBusFD.events = G_IO_IN | G_IO_PRI;
1170         g_main_context_add_poll( mpImpl->mpContext, &aDBusFD, G_PRIORITY_DEFAULT );
1171     }
1172     else
1173         SAL_WARN( "sdremote.bluetooth", "failed to poll for incoming dbus signals" );
1174
1175     if (isBluez5Available(pConnection))
1176     {
1177         SAL_INFO("sdremote.bluetooth", "Using Bluez 5");
1178         registerBluez5Profile(pConnection, mpCommunicators);
1179         mpImpl->mpConnection = pConnection;
1180         mpImpl->maBluezVersion = Impl::BluezVersion::BLUEZ5;
1181
1182         // We don't need to listen to adapter changes anymore -- profile
1183         // registration is done globally for the entirety of bluez, so we only
1184         // need adapters when setting discoverability, which can be done
1185         // dynamically without the need to listen for changes.
1186
1187         // TODO: exit on SD deinit
1188         // Probably best to do that in SdModule::~SdModule?
1189         while (true)
1190         {
1191             aDBusFD.revents = 0;
1192             g_main_context_iteration( mpImpl->mpContext, TRUE );
1193             if( aDBusFD.revents )
1194             {
1195                 dbus_connection_read_write( pConnection, 0 );
1196                 while (DBUS_DISPATCH_DATA_REMAINS == dbus_connection_get_dispatch_status( pConnection ))
1197                     dbus_connection_dispatch( pConnection );
1198             }
1199             if ((false)) break;
1200                 // silence Clang -Wunreachable-code after loop (TODO: proper
1201                 // fix?)
1202         }
1203         unregisterBluez5Profile( pConnection );
1204         g_main_context_unref( mpImpl->mpContext );
1205         mpImpl->mpConnection = nullptr;
1206         mpImpl->mpContext = nullptr;
1207         return;
1208     }
1209
1210     // Otherwise we could be on Bluez 4 and continue as usual.
1211     mpImpl->maBluezVersion = Impl::BluezVersion::BLUEZ4;
1212
1213     // Try to setup the default adapter, otherwise wait for add/remove signal
1214     mpImpl->mpService = registerWithDefaultAdapter( pConnection );
1215     // listen for connection state and power changes - we need to close
1216     // and re-create our socket code on suspend / resume, enable/disable
1217     DBusError aError;
1218     dbus_error_init( &aError );
1219     dbus_bus_add_match( pConnection, "type='signal',interface='org.bluez.Manager'", &aError );
1220     dbus_connection_flush( pConnection );
1221
1222     // Try to setup the default adapter, otherwise wait for add/remove signal
1223     mpImpl->mpService = registerWithDefaultAdapter( pConnection );
1224
1225     // poll on our bluetooth socket - if we can.
1226     GPollFD aSocketFD;
1227     if( mpImpl->mpService )
1228         bluezCreateAttachListeningSocket( mpImpl->mpContext, &aSocketFD );
1229
1230     mpImpl->mpConnection = pConnection;
1231
1232     while( true )
1233     {
1234         aDBusFD.revents = 0;
1235         aSocketFD.revents = 0;
1236         g_main_context_iteration( mpImpl->mpContext, TRUE );
1237
1238         SAL_INFO( "sdremote.bluetooth", "main-loop spin "
1239                   << aDBusFD.revents << " " << aSocketFD.revents );
1240         if( aDBusFD.revents )
1241         {
1242             dbus_connection_read_write( pConnection, 0 );
1243             DBusMessage *pMsg = dbus_connection_pop_message( pConnection );
1244             if( pMsg )
1245             {
1246                 if( dbus_message_is_signal( pMsg, "org.bluez.Manager", "AdapterRemoved" ) )
1247                 {
1248                     SAL_WARN( "sdremote.bluetooth", "lost adapter - cleaning up sockets" );
1249                     bluezDetachCloseSocket( mpImpl->mpContext, &aSocketFD );
1250                     cleanupCommunicators();
1251                 }
1252                 else if( dbus_message_is_signal( pMsg, "org.bluez.Manager", "AdapterAdded" ) ||
1253                          dbus_message_is_signal( pMsg, "org.bluez.Manager", "DefaultAdapterChanged" ) )
1254                 {
1255                     SAL_WARN( "sdremote.bluetooth", "gained adapter - re-generating sockets" );
1256                     bluezDetachCloseSocket( mpImpl->mpContext, &aSocketFD );
1257                     cleanupCommunicators();
1258                     mpImpl->mpService = registerWithDefaultAdapter( pConnection );
1259                     if( mpImpl->mpService )
1260                         bluezCreateAttachListeningSocket( mpImpl->mpContext, &aSocketFD );
1261                 }
1262                 else
1263                     SAL_INFO( "sdremote.bluetooth", "unknown incoming dbus message, "
1264                                  " type: " << dbus_message_get_type( pMsg )
1265                               << " path: '" << dbus_message_get_path( pMsg )
1266                               << "' interface: '" << dbus_message_get_interface( pMsg )
1267                               << "' member: '" << dbus_message_get_member( pMsg ) );
1268             }
1269             dbus_message_unref( pMsg );
1270         }
1271
1272         if( aSocketFD.revents )
1273         {
1274             sockaddr_rc aRemoteAddr;
1275             socklen_t aRemoteAddrLen = sizeof(aRemoteAddr);
1276
1277             int nClient;
1278             SAL_INFO( "sdremote.bluetooth", "performing accept" );
1279             if ( ( nClient = accept( aSocketFD.fd, reinterpret_cast<sockaddr*>(&aRemoteAddr), &aRemoteAddrLen)) < 0 &&
1280                  errno != EAGAIN )
1281             {
1282                 SAL_WARN( "sdremote.bluetooth", "accept failed with errno " << errno );
1283             } else {
1284                 SAL_INFO( "sdremote.bluetooth", "connection accepted " << nClient );
1285                 Communicator* pCommunicator = new Communicator( std::make_unique<BufferedStreamSocket>( nClient ) );
1286                 mpCommunicators->push_back( pCommunicator );
1287                 pCommunicator->launch();
1288             }
1289         }
1290         if ((false)) break;
1291             // silence Clang -Wunreachable-code after loop (TODO: proper fix?)
1292     }
1293
1294     unregisterBluez5Profile( pConnection );
1295     g_main_context_unref( mpImpl->mpContext );
1296     mpImpl->mpConnection = nullptr;
1297     mpImpl->mpContext = nullptr;
1298
1299 #elif defined(_WIN32)
1300     WORD wVersionRequested;
1301     WSADATA wsaData;
1302
1303     wVersionRequested = MAKEWORD(2, 2);
1304
1305     if ( WSAStartup(wVersionRequested, &wsaData) )
1306     {
1307         return; // winsock dll couldn't be loaded
1308     }
1309
1310     int aSocket = socket( AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM );
1311     if ( !aSocket )
1312     {
1313         WSACleanup();
1314         return;
1315     }
1316     SOCKADDR_BTH aAddr;
1317     aAddr.addressFamily = AF_BTH;
1318     aAddr.btAddr = 0;
1319     aAddr.serviceClassId = GUID_NULL;
1320     aAddr.port = BT_PORT_ANY; // Select any free socket.
1321     if ( bind( aSocket, reinterpret_cast<SOCKADDR*>(&aAddr), sizeof(aAddr) ) == SOCKET_ERROR )
1322     {
1323         closesocket( aSocket );
1324         WSACleanup();
1325         return;
1326     }
1327
1328     SOCKADDR_BTH aName;
1329     int aNameSize = sizeof(aName);
1330     getsockname( aSocket, reinterpret_cast<SOCKADDR*>(&aName), &aNameSize ); // Retrieve the local address and port
1331
1332     CSADDR_INFO aAddrInfo;
1333     memset( &aAddrInfo, 0, sizeof(aAddrInfo) );
1334     aAddrInfo.LocalAddr.lpSockaddr = reinterpret_cast<SOCKADDR*>(&aName);
1335     aAddrInfo.LocalAddr.iSockaddrLength = sizeof( SOCKADDR_BTH );
1336     aAddrInfo.iSocketType = SOCK_STREAM;
1337     aAddrInfo.iProtocol = BTHPROTO_RFCOMM;
1338
1339     // To be used for setting a custom UUID once available.
1340 //    GUID uuid;
1341 //    uuid.Data1 = 0x00001101;
1342 //  memset( &uuid, 0x1000 + UUID*2^96, sizeof( GUID ) );
1343 //    uuid.Data2 = 0;
1344 //    uuid.Data3 = 0x1000;
1345 //    ULONGLONG aData4 = 0x800000805F9B34FB;
1346 //    memcpy( uuid.Data4, &aData4, sizeof(uuid.Data4) );
1347
1348     WSAQUERYSETW aRecord;
1349     memset( &aRecord, 0, sizeof(aRecord));
1350     aRecord.dwSize = sizeof(aRecord);
1351     aRecord.lpszServiceInstanceName = const_cast<wchar_t *>(
1352         L"LibreOffice Impress Remote Control");
1353     aRecord.lpszComment = const_cast<wchar_t *>(
1354         L"Remote control of presentations over bluetooth.");
1355     aRecord.lpServiceClassId = const_cast<LPGUID>(&SerialPortServiceClass_UUID);
1356     aRecord.dwNameSpace = NS_BTH;
1357     aRecord.dwNumberOfCsAddrs = 1;
1358     aRecord.lpcsaBuffer = &aAddrInfo;
1359     if (WSASetServiceW( &aRecord, RNRSERVICE_REGISTER, 0 ) == SOCKET_ERROR)
1360     {
1361         closesocket( aSocket );
1362         WSACleanup();
1363         return;
1364     }
1365
1366     if ( listen( aSocket, 1 ) == SOCKET_ERROR )
1367     {
1368         closesocket( aSocket );
1369         WSACleanup();
1370         return;
1371     }
1372
1373     SOCKADDR_BTH aRemoteAddr;
1374     int aRemoteAddrLen = sizeof(aRemoteAddr);
1375     while ( true )
1376     {
1377         SOCKET socket;
1378         if ( (socket = accept(aSocket, reinterpret_cast<sockaddr*>(&aRemoteAddr), &aRemoteAddrLen)) == INVALID_SOCKET )
1379         {
1380             closesocket( aSocket );
1381             WSACleanup();
1382             return;
1383         } else {
1384             Communicator* pCommunicator = new Communicator( std::make_unique<BufferedStreamSocket>( socket) );
1385             mpCommunicators->push_back( pCommunicator );
1386             pCommunicator->launch();
1387         }
1388     }
1389
1390 #elif defined(MACOSX)
1391     // Build up dictionary at run-time instead of bothering with a
1392     // .plist file, using the Objective-C API
1393
1394     // Compare to BluetoothServiceRecord.hxx
1395
1396     NSAutoreleasePool* pool = [[NSAutoreleasePool alloc] init];
1397
1398     NSDictionary *dict =
1399         [NSDictionary dictionaryWithObjectsAndKeys:
1400
1401          // Service class ID list
1402          [NSArray arrayWithObject:
1403           [IOBluetoothSDPUUID uuid16: kBluetoothSDPUUID16ServiceClassSerialPort]],
1404          @"0001 - ServiceClassIDList",
1405
1406          // Protocol descriptor list
1407          [NSArray arrayWithObjects:
1408           [NSArray arrayWithObject: [IOBluetoothSDPUUID uuid16: kBluetoothSDPUUID16L2CAP]],
1409           [NSArray arrayWithObjects:
1410            [IOBluetoothSDPUUID uuid16: kBluetoothL2CAPPSMRFCOMM],
1411            [NSDictionary dictionaryWithObjectsAndKeys:
1412             [NSNumber numberWithInt: 1],
1413             @"DataElementSize",
1414             [NSNumber numberWithInt: 1],
1415             @"DataElementType",
1416             [NSNumber numberWithInt: 5], // RFCOMM port number, will be replaced if necessary automatically
1417             @"DataElementValue",
1418             nil],
1419            nil],
1420           nil],
1421          @"0004 - Protocol descriptor list",
1422
1423          // Browse group list
1424          [NSArray arrayWithObject:
1425           [IOBluetoothSDPUUID uuid16: kBluetoothSDPUUID16ServiceClassPublicBrowseGroup]],
1426          @"0005 - BrowseGroupList",
1427
1428          // Language base attribute ID list
1429          [NSArray arrayWithObjects:
1430           [NSData dataWithBytes: "en" length: 2],
1431           [NSDictionary dictionaryWithObjectsAndKeys:
1432            [NSNumber numberWithInt: 2],
1433            @"DataElementSize",
1434            [NSNumber numberWithInt: 1],
1435            @"DataElementType",
1436            [NSNumber numberWithInt: 0x006a], // encoding
1437            @"DataElementValue",
1438            nil],
1439           [NSDictionary dictionaryWithObjectsAndKeys:
1440            [NSNumber numberWithInt: 2],
1441            @"DataElementSize",
1442            [NSNumber numberWithInt: 1],
1443            @"DataElementType",
1444            [NSNumber numberWithInt: 0x0100], // offset
1445            @"DataElementValue",
1446            nil],
1447           nil],
1448          @"0006 - LanguageBaseAttributeIDList",
1449
1450          // Bluetooth profile descriptor list
1451          [NSArray arrayWithObject:
1452           [NSArray arrayWithObjects:
1453            [IOBluetoothSDPUUID uuid16: kBluetoothSDPUUID16ServiceClassSerialPort],
1454            [NSDictionary dictionaryWithObjectsAndKeys:
1455             [NSNumber numberWithInt: 2],
1456             @"DataElementSize",
1457             [NSNumber numberWithInt: 1],
1458             @"DataElementType",
1459             [NSNumber numberWithInt: 0x0100], // version number ?
1460             @"DataElementValue",
1461             nil],
1462            nil]],
1463          @"0009 - BluetoothProfileDescriptorList",
1464
1465          // Attributes pointed to by the LanguageBaseAttributeIDList
1466          @"LibreOffice Impress Remote Control",
1467          @"0100 - ServiceName",
1468          @"The Document Foundation",
1469          @"0102 - ProviderName",
1470          nil];
1471
1472     // Create service
1473     IOBluetoothSDPServiceRecordRef serviceRecordRef;
1474     SAL_WNODEPRECATED_DECLARATIONS_PUSH //TODO: 10.9 IOBluetoothAddServiceDict
1475     IOReturn rc = IOBluetoothAddServiceDict(reinterpret_cast<CFDictionaryRef>(dict), &serviceRecordRef);
1476     SAL_WNODEPRECATED_DECLARATIONS_POP
1477
1478     SAL_INFO("sdremote.bluetooth", "IOBluetoothAddServiceDict returned " << rc);
1479
1480     if (rc == kIOReturnSuccess)
1481     {
1482         IOBluetoothSDPServiceRecord *serviceRecord =
1483             [IOBluetoothSDPServiceRecord withSDPServiceRecordRef: serviceRecordRef];
1484
1485         BluetoothRFCOMMChannelID channelID;
1486         [serviceRecord getRFCOMMChannelID: &channelID];
1487
1488         BluetoothSDPServiceRecordHandle serviceRecordHandle;
1489         [serviceRecord getServiceRecordHandle: &serviceRecordHandle];
1490
1491         // Register callback for incoming connections
1492         IOBluetoothRegisterForFilteredRFCOMMChannelOpenNotifications(
1493             incomingCallback,
1494             this,
1495             channelID,
1496             kIOBluetoothUserNotificationChannelDirectionIncoming);
1497
1498         [serviceRecord release];
1499     }
1500
1501     [pool release];
1502
1503     (void) mpCommunicators;
1504 #else
1505     (void) mpCommunicators; // avoid warnings about unused member
1506 #endif
1507 }
1508
1509 BluetoothServer *sd::BluetoothServer::spServer = nullptr;
1510
1511 void BluetoothServer::setup( std::vector<Communicator*>* pCommunicators )
1512 {
1513     if (spServer)
1514         return;
1515
1516     spServer = new BluetoothServer( pCommunicators );
1517     spServer->create();
1518 }
1519
1520 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */