| /* |
| * |
| * Copyright (c) 2020-2022 Project CHIP Authors |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /* |
| * Copyright (c) 2016-2019, The OpenThread Authors. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the copyright holder nor the |
| * names of its contributors may be used to endorse or promote products |
| * derived from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "BluezEndpoint.h" |
| |
| #include <cstring> |
| #include <errno.h> |
| #include <memory> |
| #include <sys/socket.h> |
| #include <unistd.h> |
| #include <utility> |
| |
| #include <gio/gio.h> |
| #include <gio/gunixfdlist.h> |
| #include <glib-object.h> |
| #include <glib.h> |
| |
| #include <ble/Ble.h> |
| #include <lib/support/BitFlags.h> |
| #include <lib/support/CHIPMem.h> |
| #include <lib/support/CodeUtils.h> |
| #include <lib/support/logging/CHIPLogging.h> |
| #include <platform/ConfigurationManager.h> |
| #include <platform/ConnectivityManager.h> |
| #include <platform/DeviceInstanceInfoProvider.h> |
| #include <platform/GLibTypeDeleter.h> |
| #include <platform/Linux/dbus/bluez/DbusBluez.h> |
| #include <platform/PlatformManager.h> |
| #include <platform/internal/BLEManager.h> |
| #include <setup_payload/AdditionalDataPayloadGenerator.h> |
| #include <system/SystemPacketBuffer.h> |
| |
| #include "BluezConnection.h" |
| #include "Types.h" |
| |
| #if !GLIB_CHECK_VERSION(2, 68, 0) |
| #define g_memdup2(mem, size) g_memdup(mem, static_cast<unsigned int>(size)) |
| #endif |
| |
| namespace chip { |
| namespace DeviceLayer { |
| namespace Internal { |
| |
| constexpr uint16_t kMaxConnectRetries = 4; |
| |
| gboolean BluezEndpoint::BluezCharacteristicReadValue(BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInvocation, |
| GVariant * aOptions) |
| { |
| ChipLogDetail(DeviceLayer, "Received %s", __func__); |
| GVariant * val = bluez_gatt_characteristic1_get_value(aChar); |
| bluez_gatt_characteristic1_complete_read_value(aChar, aInvocation, val); |
| return TRUE; |
| } |
| |
| gboolean BluezEndpoint::BluezCharacteristicAcquireWrite(BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInvocation, |
| GUnixFDList * aFDList, GVariant * aOptions) |
| { |
| int fds[2] = { -1, -1 }; |
| #if CHIP_ERROR_LOGGING |
| char * errStr; |
| #endif // CHIP_ERROR_LOGGING |
| BluezConnection * conn = nullptr; |
| GAutoPtr<GVariant> option_mtu; |
| uint16_t mtu; |
| |
| conn = GetBluezConnectionViaDevice(); |
| VerifyOrReturnValue( |
| conn != nullptr, FALSE, |
| g_dbus_method_invocation_return_dbus_error(aInvocation, "org.bluez.Error.Failed", "No CHIPoBLE connection")); |
| |
| ChipLogDetail(DeviceLayer, "BluezCharacteristicAcquireWrite is called, conn: %p", conn); |
| |
| VerifyOrReturnValue( |
| g_variant_lookup(aOptions, "mtu", "q", &mtu), FALSE, ChipLogError(DeviceLayer, "FAIL: No MTU in options in %s", __func__); |
| g_dbus_method_invocation_return_dbus_error(aInvocation, "org.bluez.Error.InvalidArguments", "MTU negotiation failed")); |
| conn->SetMTU(mtu); |
| |
| if (socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, fds) < 0) |
| { |
| #if CHIP_ERROR_LOGGING |
| errStr = strerror(errno); |
| #endif // CHIP_ERROR_LOGGING |
| ChipLogError(DeviceLayer, "FAIL: socketpair: %s in %s", StringOrNullMarker(errStr), __func__); |
| g_dbus_method_invocation_return_dbus_error(aInvocation, "org.bluez.Error.Failed", "FD creation failed"); |
| return FALSE; |
| } |
| |
| conn->SetupWriteHandler(fds[0]); |
| bluez_gatt_characteristic1_set_write_acquired(aChar, TRUE); |
| |
| GUnixFDList * fdList = g_unix_fd_list_new_from_array(&fds[1], 1); |
| bluez_gatt_characteristic1_complete_acquire_write(aChar, aInvocation, fdList, g_variant_new_handle(0), conn->GetMTU()); |
| g_object_unref(fdList); |
| |
| return TRUE; |
| } |
| |
| static gboolean BluezCharacteristicAcquireWriteError(BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInvocation, |
| GUnixFDList * aFDList, GVariant * aOptions) |
| { |
| ChipLogDetail(DeviceLayer, "Received %s", __func__); |
| g_dbus_method_invocation_return_dbus_error(aInvocation, "org.bluez.Error.NotSupported", |
| "AcquireWrite for characteristic is unsupported"); |
| return TRUE; |
| } |
| |
| gboolean BluezEndpoint::BluezCharacteristicAcquireNotify(BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInvocation, |
| GUnixFDList * aFDList, GVariant * aOptions) |
| { |
| int fds[2] = { -1, -1 }; |
| #if CHIP_ERROR_LOGGING |
| char * errStr; |
| #endif // CHIP_ERROR_LOGGING |
| BluezConnection * conn = nullptr; |
| bool isAdditionalAdvertising = false; |
| GAutoPtr<GVariant> option_mtu; |
| uint16_t mtu; |
| |
| #if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING |
| isAdditionalAdvertising = (aChar == mC3.get()); |
| #endif |
| |
| if (bluez_gatt_characteristic1_get_notifying(aChar)) |
| { |
| g_dbus_method_invocation_return_dbus_error(aInvocation, "org.bluez.Error.NotPermitted", "Already notifying"); |
| return FALSE; |
| } |
| |
| conn = GetBluezConnectionViaDevice(); |
| VerifyOrReturnValue( |
| conn != nullptr, FALSE, |
| g_dbus_method_invocation_return_dbus_error(aInvocation, "org.bluez.Error.Failed", "No CHIPoBLE connection")); |
| |
| VerifyOrReturnValue( |
| g_variant_lookup(aOptions, "mtu", "q", &mtu), FALSE, ChipLogError(DeviceLayer, "FAIL: No MTU in options in %s", __func__); |
| g_dbus_method_invocation_return_dbus_error(aInvocation, "org.bluez.Error.InvalidArguments", "MTU negotiation failed");); |
| conn->SetMTU(mtu); |
| |
| if (socketpair(AF_UNIX, SOCK_SEQPACKET | SOCK_NONBLOCK | SOCK_CLOEXEC, 0, fds) < 0) |
| { |
| #if CHIP_ERROR_LOGGING |
| errStr = strerror(errno); |
| #endif // CHIP_ERROR_LOGGING |
| ChipLogError(DeviceLayer, "FAIL: socketpair: %s in %s", StringOrNullMarker(errStr), __func__); |
| g_dbus_method_invocation_return_dbus_error(aInvocation, "org.bluez.Error.Failed", "FD creation failed"); |
| return FALSE; |
| } |
| |
| conn->SetupNotifyHandler(fds[0], isAdditionalAdvertising); |
| bluez_gatt_characteristic1_set_notify_acquired(aChar, TRUE); |
| conn->SetNotifyAcquired(true); |
| |
| GUnixFDList * fdList = g_unix_fd_list_new_from_array(&fds[1], 1); |
| bluez_gatt_characteristic1_complete_acquire_notify(aChar, aInvocation, fdList, g_variant_new_handle(0), conn->GetMTU()); |
| g_object_unref(fdList); |
| |
| BLEManagerImpl::HandleTXCharCCCDWrite(conn); |
| |
| return TRUE; |
| } |
| |
| static gboolean BluezCharacteristicAcquireNotifyError(BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInvocation, |
| GVariant * aOptions) |
| { |
| ChipLogDetail(DeviceLayer, "Received %s", __func__); |
| g_dbus_method_invocation_return_dbus_error(aInvocation, "org.bluez.Error.NotSupported", |
| "AcquireNotify for characteristic is unsupported"); |
| return TRUE; |
| } |
| |
| gboolean BluezEndpoint::BluezCharacteristicConfirm(BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInvocation) |
| { |
| BluezConnection * conn = GetBluezConnectionViaDevice(); |
| ChipLogDetail(Ble, "Indication confirmation, %p", conn); |
| bluez_gatt_characteristic1_complete_confirm(aChar, aInvocation); |
| BLEManagerImpl::HandleTXComplete(conn); |
| return TRUE; |
| } |
| |
| static gboolean BluezCharacteristicConfirmError(BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInvocation) |
| { |
| g_dbus_method_invocation_return_dbus_error(aInvocation, "org.bluez.Error.Failed", "Confirm from characteristic is unsupported"); |
| return TRUE; |
| } |
| |
| BluezGattCharacteristic1 * BluezEndpoint::CreateGattCharacteristic(BluezGattService1 * aService, const char * aCharName, |
| const char * aUUID, const char * const * aFlags) |
| { |
| const char * servicePath = g_dbus_object_get_object_path(g_dbus_interface_get_object(G_DBUS_INTERFACE(aService))); |
| GAutoPtr<char> charPath(g_strdup_printf("%s/%s", servicePath, aCharName)); |
| BluezObjectSkeleton * object; |
| BluezGattCharacteristic1 * characteristic; |
| |
| ChipLogDetail(DeviceLayer, "Create characteristic object at %s", charPath.get()); |
| object = bluez_object_skeleton_new(charPath.get()); |
| |
| characteristic = bluez_gatt_characteristic1_skeleton_new(); |
| bluez_gatt_characteristic1_set_uuid(characteristic, aUUID); |
| bluez_gatt_characteristic1_set_flags(characteristic, aFlags); |
| bluez_gatt_characteristic1_set_service(characteristic, servicePath); |
| |
| // Initialize value to empty array, so it can be read without prior write from the client side. |
| auto value = g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE, nullptr, 0, sizeof(uint8_t)); |
| bluez_gatt_characteristic1_set_value(characteristic, value); |
| |
| bluez_object_skeleton_set_gatt_characteristic1(object, characteristic); |
| g_dbus_object_manager_server_export(mRoot.get(), G_DBUS_OBJECT_SKELETON(object)); |
| g_object_unref(object); |
| |
| return characteristic; |
| } |
| |
| void BluezEndpoint::RegisterGattApplicationDone(GObject * aObject, GAsyncResult * aResult) |
| { |
| GAutoPtr<GError> error; |
| if (!bluez_gatt_manager1_call_register_application_finish(reinterpret_cast<BluezGattManager1 *>(aObject), aResult, |
| &error.GetReceiver())) |
| { |
| ChipLogError(DeviceLayer, "FAIL: RegisterGattApplication: %s", error->message); |
| BLEManagerImpl::NotifyBLEPeripheralRegisterAppComplete(BluezCallToChipError(error.get())); |
| return; |
| } |
| |
| ChipLogDetail(DeviceLayer, "GATT application registered successfully"); |
| BLEManagerImpl::NotifyBLEPeripheralRegisterAppComplete(CHIP_NO_ERROR); |
| } |
| |
| CHIP_ERROR BluezEndpoint::RegisterGattApplicationImpl() |
| { |
| VerifyOrReturnError(mAdapter, CHIP_ERROR_UNINITIALIZED); |
| |
| // If the adapter configured in the Init() was unplugged, the g_dbus_interface_get_object() |
| // or bluez_object_get_gatt_manager1() might return nullptr (depending on the timing, since |
| // the D-Bus communication is handled on a separate thread). In such case, we should not |
| // report internal error, but adapter unavailable, so the application can handle the situation |
| // properly. |
| |
| GDBusObject * adapterObject = g_dbus_interface_get_object(reinterpret_cast<GDBusInterface *>(mAdapter.get())); |
| VerifyOrReturnError(adapterObject != nullptr, BLE_ERROR_ADAPTER_UNAVAILABLE); |
| GAutoPtr<BluezGattManager1> gattMgr(bluez_object_get_gatt_manager1(reinterpret_cast<BluezObject *>(adapterObject))); |
| VerifyOrReturnError(gattMgr, BLE_ERROR_ADAPTER_UNAVAILABLE); |
| |
| GVariantBuilder optionsBuilder; |
| g_variant_builder_init(&optionsBuilder, G_VARIANT_TYPE("a{sv}")); |
| GVariant * options = g_variant_builder_end(&optionsBuilder); |
| |
| bluez_gatt_manager1_call_register_application( |
| gattMgr.get(), mpRootPath, options, nullptr, |
| +[](GObject * aObj, GAsyncResult * aResult, void * self) { |
| reinterpret_cast<BluezEndpoint *>(self)->RegisterGattApplicationDone(aObj, aResult); |
| }, |
| this); |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| /// Update the table of open BLE connections whenever a new device is spotted or its attributes have changed. |
| void BluezEndpoint::UpdateConnectionTable(BluezDevice1 & aDevice) |
| { |
| const char * objectPath = g_dbus_proxy_get_object_path(reinterpret_cast<GDBusProxy *>(&aDevice)); |
| BluezConnection * conn = GetBluezConnection(objectPath); |
| |
| if (conn != nullptr && !bluez_device1_get_connected(&aDevice)) |
| { |
| ChipLogDetail(DeviceLayer, "BLE connection closed: conn=%p", conn); |
| BLEManagerImpl::HandleConnectionClosed(conn); |
| mConnMap.erase(objectPath); |
| // TODO: the connection object should be released after BLEManagerImpl finishes cleaning up its resources |
| // after the disconnection. Releasing it here doesn't cause any issues, but it's error-prone. |
| chip::Platform::Delete(conn); |
| return; |
| } |
| |
| if (conn == nullptr) |
| { |
| HandleNewDevice(aDevice); |
| } |
| } |
| |
| void BluezEndpoint::HandleNewDevice(BluezDevice1 & aDevice) |
| { |
| VerifyOrReturn(bluez_device1_get_connected(&aDevice)); |
| VerifyOrReturn(!mIsCentral || bluez_device1_get_services_resolved(&aDevice)); |
| CHIP_ERROR err; |
| |
| const char * objectPath = g_dbus_proxy_get_object_path(reinterpret_cast<GDBusProxy *>(&aDevice)); |
| BluezConnection * conn = GetBluezConnection(objectPath); |
| VerifyOrReturn(conn == nullptr, |
| ChipLogError(DeviceLayer, "FAIL: Connection already tracked: conn=%p device=%s path=%s", conn, |
| conn->GetPeerAddress(), objectPath)); |
| |
| conn = chip::Platform::New<BluezConnection>(aDevice); |
| VerifyOrExit(conn != nullptr, err = CHIP_ERROR_NO_MEMORY); |
| SuccessOrExit(err = conn->Init(*this)); |
| |
| mpPeerDevicePath = g_strdup(objectPath); |
| mConnMap[mpPeerDevicePath] = conn; |
| |
| ChipLogDetail(DeviceLayer, "New BLE connection: conn=%p device=%s path=%s", conn, conn->GetPeerAddress(), objectPath); |
| |
| BLEManagerImpl::HandleNewConnection(conn); |
| return; |
| |
| exit: |
| chip::Platform::Delete(conn); |
| BLEManagerImpl::HandleConnectFailed(err); |
| } |
| |
| void BluezEndpoint::OnDeviceAdded(BluezDevice1 & device) |
| { |
| HandleNewDevice(device); |
| } |
| |
| void BluezEndpoint::OnDevicePropertyChanged(BluezDevice1 & device, GVariant * changedProps, const char * const * invalidatedProps) |
| { |
| UpdateConnectionTable(device); |
| } |
| |
| void BluezEndpoint::OnDeviceRemoved(BluezDevice1 & device) |
| { |
| // Handling device removal is not necessary because disconnection is already handled |
| // in the OnDevicePropertyChanged() - we are checking for the "Connected" property. |
| } |
| |
| BluezGattService1 * BluezEndpoint::CreateGattService(const char * aUUID) |
| { |
| BluezObjectSkeleton * object; |
| BluezGattService1 * service; |
| |
| mpServicePath = g_strdup_printf("%s/service", mpRootPath); |
| ChipLogDetail(DeviceLayer, "CREATE service object at %s", mpServicePath); |
| object = bluez_object_skeleton_new(mpServicePath); |
| |
| service = bluez_gatt_service1_skeleton_new(); |
| bluez_gatt_service1_set_uuid(service, aUUID); |
| // device is only valid for remote services |
| bluez_gatt_service1_set_primary(service, TRUE); |
| |
| // includes -- unclear whether required. Might be filled in later |
| bluez_object_skeleton_set_gatt_service1(object, service); |
| g_dbus_object_manager_server_export(mRoot.get(), G_DBUS_OBJECT_SKELETON(object)); |
| g_object_unref(object); |
| |
| return service; |
| } |
| |
| BluezConnection * BluezEndpoint::GetBluezConnection(const char * aPath) |
| { |
| auto it = mConnMap.find(aPath); |
| return (it != mConnMap.end()) ? it->second : nullptr; |
| } |
| |
| BluezConnection * BluezEndpoint::GetBluezConnectionViaDevice() |
| { |
| return GetBluezConnection(mpPeerDevicePath); |
| } |
| |
| #if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING |
| static void UpdateAdditionalDataCharacteristic(BluezGattCharacteristic1 * characteristic) |
| { |
| VerifyOrReturn(characteristic != nullptr); |
| |
| // Construct the TLV for the additional data |
| GVariant * cValue = nullptr; |
| gpointer data; |
| CHIP_ERROR err = CHIP_NO_ERROR; |
| chip::System::PacketBufferHandle bufferHandle; |
| BitFlags<AdditionalDataFields> additionalDataFields; |
| AdditionalDataPayloadGeneratorParams additionalDataPayloadParams; |
| |
| #if CHIP_ENABLE_ROTATING_DEVICE_ID && defined(CHIP_DEVICE_CONFIG_ROTATING_DEVICE_ID_UNIQUE_ID) |
| uint8_t rotatingDeviceIdUniqueId[ConfigurationManager::kRotatingDeviceIDUniqueIDLength] = {}; |
| MutableByteSpan rotatingDeviceIdUniqueIdSpan(rotatingDeviceIdUniqueId); |
| |
| err = GetDeviceInstanceInfoProvider()->GetRotatingDeviceIdUniqueId(rotatingDeviceIdUniqueIdSpan); |
| SuccessOrExit(err); |
| err = ConfigurationMgr().GetLifetimeCounter(additionalDataPayloadParams.rotatingDeviceIdLifetimeCounter); |
| SuccessOrExit(err); |
| additionalDataPayloadParams.rotatingDeviceIdUniqueId = rotatingDeviceIdUniqueIdSpan; |
| additionalDataFields.Set(AdditionalDataFields::RotatingDeviceId); |
| #endif /* CHIP_ENABLE_ROTATING_DEVICE_ID && defined(CHIP_DEVICE_CONFIG_ROTATING_DEVICE_ID_UNIQUE_ID) */ |
| |
| err = AdditionalDataPayloadGenerator().generateAdditionalDataPayload(additionalDataPayloadParams, bufferHandle, |
| additionalDataFields); |
| SuccessOrExit(err); |
| |
| data = g_memdup2(bufferHandle->Start(), bufferHandle->DataLength()); |
| |
| cValue = g_variant_new_from_data(G_VARIANT_TYPE("ay"), data, bufferHandle->DataLength(), TRUE, g_free, data); |
| bluez_gatt_characteristic1_set_value(characteristic, cValue); |
| |
| return; |
| |
| exit: |
| if (err != CHIP_NO_ERROR) |
| { |
| ChipLogError(DeviceLayer, "Failed to generate TLV encoded Additional Data (%s)", __func__); |
| } |
| return; |
| } |
| #endif |
| |
| void BluezEndpoint::SetupGattService() |
| { |
| |
| static const char * const c1_flags[] = { "write", nullptr }; |
| static const char * const c2_flags[] = { "indicate", nullptr }; |
| #if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING |
| static const char * const c3_flags[] = { "read", nullptr }; |
| #endif |
| |
| mService.reset(CreateGattService(Ble::CHIP_BLE_SERVICE_SHORT_UUID_STR)); |
| |
| // C1 characteristic |
| mC1.reset(CreateGattCharacteristic(mService.get(), "c1", Ble::CHIP_BLE_CHAR_1_UUID_STR, c1_flags)); |
| g_signal_connect(mC1.get(), "handle-read-value", |
| G_CALLBACK(+[](BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInv, GVariant * aOpt, |
| BluezEndpoint * self) { return self->BluezCharacteristicReadValue(aChar, aInv, aOpt); }), |
| this); |
| g_signal_connect( |
| mC1.get(), "handle-acquire-write", |
| G_CALLBACK(+[](BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInv, GUnixFDList * aFDList, GVariant * aOpt, |
| BluezEndpoint * self) { return self->BluezCharacteristicAcquireWrite(aChar, aInv, aFDList, aOpt); }), |
| this); |
| g_signal_connect(mC1.get(), "handle-acquire-notify", G_CALLBACK(BluezCharacteristicAcquireNotifyError), nullptr); |
| g_signal_connect(mC1.get(), "handle-confirm", G_CALLBACK(BluezCharacteristicConfirmError), nullptr); |
| |
| // C2 characteristic |
| mC2.reset(CreateGattCharacteristic(mService.get(), "c2", Ble::CHIP_BLE_CHAR_2_UUID_STR, c2_flags)); |
| g_signal_connect(mC2.get(), "handle-read-value", |
| G_CALLBACK(+[](BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInv, GVariant * aOpt, |
| BluezEndpoint * self) { return self->BluezCharacteristicReadValue(aChar, aInv, aOpt); }), |
| this); |
| g_signal_connect(mC2.get(), "handle-acquire-write", G_CALLBACK(BluezCharacteristicAcquireWriteError), nullptr); |
| g_signal_connect( |
| mC2.get(), "handle-acquire-notify", |
| G_CALLBACK(+[](BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInv, GUnixFDList * aFDList, GVariant * aOpt, |
| BluezEndpoint * self) { return self->BluezCharacteristicAcquireNotify(aChar, aInv, aFDList, aOpt); }), |
| this); |
| g_signal_connect(mC2.get(), "handle-confirm", |
| G_CALLBACK(+[](BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInv, BluezEndpoint * self) { |
| return self->BluezCharacteristicConfirm(aChar, aInv); |
| }), |
| this); |
| |
| ChipLogDetail(DeviceLayer, "CHIP BTP C1 %s", bluez_gatt_characteristic1_get_service(mC1.get())); |
| ChipLogDetail(DeviceLayer, "CHIP BTP C2 %s", bluez_gatt_characteristic1_get_service(mC2.get())); |
| |
| #if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING |
| ChipLogDetail(DeviceLayer, "CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING is TRUE"); |
| // Additional data characteristics |
| mC3.reset(CreateGattCharacteristic(mService.get(), "c3", Ble::CHIP_BLE_CHAR_3_UUID_STR, c3_flags)); |
| g_signal_connect(mC3.get(), "handle-read-value", |
| G_CALLBACK(+[](BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInv, GVariant * aOpt, |
| BluezEndpoint * self) { return self->BluezCharacteristicReadValue(aChar, aInv, aOpt); }), |
| this); |
| g_signal_connect(mC3.get(), "handle-acquire-write", G_CALLBACK(BluezCharacteristicAcquireWriteError), nullptr); |
| g_signal_connect( |
| mC3.get(), "handle-acquire-notify", |
| G_CALLBACK(+[](BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInv, GUnixFDList * aFDList, GVariant * aOpt, |
| BluezEndpoint * self) { return self->BluezCharacteristicAcquireNotify(aChar, aInv, aFDList, aOpt); }), |
| this); |
| g_signal_connect(mC3.get(), "handle-confirm", |
| G_CALLBACK(+[](BluezGattCharacteristic1 * aChar, GDBusMethodInvocation * aInv, BluezEndpoint * self) { |
| return self->BluezCharacteristicConfirm(aChar, aInv); |
| }), |
| this); |
| |
| // update the characteristic value |
| UpdateAdditionalDataCharacteristic(mC3.get()); |
| ChipLogDetail(DeviceLayer, "CHIP BTP C3 %s", bluez_gatt_characteristic1_get_service(mC3.get())); |
| #else |
| ChipLogDetail(DeviceLayer, "CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING is FALSE"); |
| #endif |
| } |
| |
| void BluezEndpoint::SetupGattServer(GDBusConnection * aConn) |
| { |
| VerifyOrReturn(!mIsCentral); |
| |
| mpRootPath = g_strdup_printf("/chipoble/%04x", getpid() & 0xffff); |
| mRoot.reset(g_dbus_object_manager_server_new(mpRootPath)); |
| |
| SetupGattService(); |
| |
| // Set connection after the service is set up in order to reduce the number |
| // of signals sent on the bus. |
| g_dbus_object_manager_server_set_connection(mRoot.get(), aConn); |
| } |
| |
| CHIP_ERROR BluezEndpoint::SetupEndpointBindings() |
| { |
| SetupGattServer(mObjectManager.GetConnection()); |
| return CHIP_NO_ERROR; |
| } |
| |
| CHIP_ERROR BluezEndpoint::RegisterGattApplication() |
| { |
| return PlatformMgrImpl().GLibMatterContextInvokeSync( |
| +[](BluezEndpoint * self) { return self->RegisterGattApplicationImpl(); }, this); |
| } |
| |
| CHIP_ERROR BluezEndpoint::Init(BluezAdapter1 * apAdapter, bool aIsCentral) |
| { |
| VerifyOrReturnError(!mIsInitialized, CHIP_ERROR_INCORRECT_STATE); |
| VerifyOrReturnError(apAdapter != nullptr, CHIP_ERROR_INVALID_ARGUMENT); |
| |
| mAdapter.reset(reinterpret_cast<BluezAdapter1 *>(g_object_ref(apAdapter))); |
| mIsCentral = aIsCentral; |
| |
| CHIP_ERROR err = mObjectManager.SubscribeDeviceNotifications(mAdapter.get(), this); |
| VerifyOrReturnError(err == CHIP_NO_ERROR, err, |
| ChipLogError(DeviceLayer, "Failed to subscribe for notifications: %" CHIP_ERROR_FORMAT, err.Format())); |
| |
| err = PlatformMgrImpl().GLibMatterContextInvokeSync( |
| +[](BluezEndpoint * self) { return self->SetupEndpointBindings(); }, this); |
| VerifyOrReturnError(err == CHIP_NO_ERROR, err, |
| ChipLogError(DeviceLayer, "Failed to schedule endpoint initialization: %" CHIP_ERROR_FORMAT, err.Format())); |
| |
| mIsInitialized = true; |
| |
| return CHIP_NO_ERROR; |
| } |
| |
| void BluezEndpoint::Shutdown() |
| { |
| VerifyOrReturn(mIsInitialized); |
| |
| // Run endpoint cleanup on the CHIPoBluez thread. This is necessary because the |
| // cleanup function releases the D-Bus manager client object, which handles D-Bus |
| // signals. Otherwise, we will face race condition when the D-Bus signal is in |
| // the middle of being processed when the cleanup function is called. |
| PlatformMgrImpl().GLibMatterContextInvokeSync( |
| +[](BluezEndpoint * self) { |
| self->mAdapter.reset(); |
| self->mRoot.reset(); |
| self->mService.reset(); |
| self->mC1.reset(); |
| self->mC2.reset(); |
| #if CHIP_ENABLE_ADDITIONAL_DATA_ADVERTISING |
| self->mC3.reset(); |
| #endif |
| return CHIP_NO_ERROR; |
| }, |
| this); |
| |
| g_free(mpRootPath); |
| g_free(mpServicePath); |
| g_free(mpPeerDevicePath); |
| |
| mIsInitialized = false; |
| } |
| |
| // ConnectDevice callbacks |
| |
| CHIP_ERROR BluezEndpoint::ConnectDeviceImpl(BluezDevice1 & aDevice) |
| { |
| // Due to radio interferences or Wi-Fi coexistence, sometimes the BLE connection may not be |
| // established (e.g. Connection Indication Packet is missed by BLE peripheral). In such case, |
| // BlueZ returns "Software caused connection abort error", and we should make a connection retry. |
| // It's important to make sure that the connection is correctly ceased, by calling `Disconnect()` |
| // D-Bus method, or else `Connect()` returns immediately without any effect. |
| for (uint16_t i = 0; i < kMaxConnectRetries; i++) |
| { |
| GAutoPtr<GError> error; |
| if (bluez_device1_call_connect_sync(&aDevice, mConnectCancellable.get(), &error.GetReceiver())) |
| { |
| ChipLogDetail(DeviceLayer, "ConnectDevice complete"); |
| return CHIP_NO_ERROR; |
| } |
| |
| ChipLogError(DeviceLayer, "FAIL: ConnectDevice: %s (%d)", error->message, error->code); |
| if (!g_error_matches(error.get(), G_IO_ERROR, G_IO_ERROR_DBUS_ERROR)) |
| { |
| break; |
| } |
| |
| ChipLogProgress(DeviceLayer, "ConnectDevice retry: %u out of %u", i + 1, kMaxConnectRetries); |
| bluez_device1_call_disconnect_sync(&aDevice, nullptr, nullptr); |
| } |
| |
| BLEManagerImpl::HandleConnectFailed(CHIP_ERROR_INTERNAL); |
| return CHIP_ERROR_INTERNAL; |
| } |
| |
| CHIP_ERROR BluezEndpoint::ConnectDevice(BluezDevice1 & aDevice) |
| { |
| auto params = std::make_pair(this, &aDevice); |
| mConnectCancellable.reset(g_cancellable_new()); |
| return PlatformMgrImpl().GLibMatterContextInvokeSync( |
| +[](decltype(params) * aParams) { return aParams->first->ConnectDeviceImpl(*aParams->second); }, ¶ms); |
| } |
| |
| void BluezEndpoint::CancelConnect() |
| { |
| g_cancellable_cancel(mConnectCancellable.get()); |
| mConnectCancellable.reset(); |
| } |
| |
| } // namespace Internal |
| } // namespace DeviceLayer |
| } // namespace chip |
