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