diff options
Diffstat (limited to 'src/core/devices/bluetooth/nm-bluez-manager.c')
| -rw-r--r-- | src/core/devices/bluetooth/nm-bluez-manager.c | 2896 |
1 files changed, 2896 insertions, 0 deletions
diff --git a/src/core/devices/bluetooth/nm-bluez-manager.c b/src/core/devices/bluetooth/nm-bluez-manager.c new file mode 100644 index 00000000..dd998d29 --- /dev/null +++ b/src/core/devices/bluetooth/nm-bluez-manager.c @@ -0,0 +1,2896 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ +/* + * Copyright (C) 2013 - 2014 Red Hat, Inc. + */ + +#include "src/core/nm-default-daemon.h" + +#include "nm-bluez-manager.h" + +#include <signal.h> +#include <stdlib.h> +#include <gmodule.h> +#include <linux/if_ether.h> + +#include "nm-glib-aux/nm-dbus-aux.h" +#include "nm-glib-aux/nm-c-list.h" +#include "nm-dbus-manager.h" +#include "devices/nm-device-factory.h" +#include "devices/nm-device-bridge.h" +#include "nm-setting-bluetooth.h" +#include "settings/nm-settings.h" +#include "nm-bluez-common.h" +#include "nm-device-bt.h" +#include "nm-manager.h" +#include "nm-bluez5-dun.h" +#include "nm-core-internal.h" +#include "platform/nm-platform.h" +#include "nm-std-aux/nm-dbus-compat.h" + +/*****************************************************************************/ + +#if WITH_BLUEZ5_DUN + #define _NM_BT_CAPABILITY_SUPPORTED_DUN NM_BT_CAPABILITY_DUN +#else + #define _NM_BT_CAPABILITY_SUPPORTED_DUN NM_BT_CAPABILITY_NONE +#endif +#define _NM_BT_CAPABILITY_SUPPORTED (NM_BT_CAPABILITY_NAP | _NM_BT_CAPABILITY_SUPPORTED_DUN) + +typedef struct { + const char * bdaddr; + CList lst_head; + NMBluetoothCapabilities bt_type : 8; + char bdaddr_data[]; +} ConnDataHead; + +typedef struct { + NMSettingsConnection *sett_conn; + ConnDataHead * cdata_hd; + CList lst; +} ConnDataElem; + +typedef struct { + GCancellable * ext_cancellable; + GCancellable * int_cancellable; + NMBtVTableRegisterCallback callback; + gpointer callback_user_data; + gulong ext_cancelled_id; +} NetworkServerRegisterReqData; + +typedef struct { + GCancellable * ext_cancellable; + GCancellable * int_cancellable; + NMBluezManagerConnectCb callback; + gpointer callback_user_data; + char * device_name; + gulong ext_cancelled_id; + guint timeout_id; + guint timeout_wait_connect_id; +} DeviceConnectReqData; + +typedef struct { + const char *object_path; + + NMBluezManager *self; + + /* Fields name with "d_" prefix are purely cached values from BlueZ's + * ObjectManager D-Bus interface. There is no logic whatsoever about + * them. + */ + + CList process_change_lst; + + struct { + char *address; + } d_adapter; + + struct { + char *address; + char *name; + char *adapter; + } d_device; + + struct { + char *interface; + } d_network; + + struct { + CList lst; + char * adapter_address; + NMDevice * device_br; + NetworkServerRegisterReqData *r_req_data; + } x_network_server; + + struct { + NMSettingsConnection *panu_connection; + NMDeviceBt * device_bt; + DeviceConnectReqData *c_req_data; + NMBluez5DunContext * connect_dun_context; + gulong device_bt_signal_id; + } x_device; + + /* indicate whether the D-Bus object has the particular D-Bus interface. */ + bool d_has_adapter_iface : 1; + bool d_has_device_iface : 1; + bool d_has_network_iface : 1; + bool d_has_network_server_iface : 1; + + /* cached D-Bus properties for Device1 ("d_device*"). */ + NMBluetoothCapabilities d_device_capabilities : 6; + bool d_device_connected : 1; + bool d_device_paired : 1; + + /* cached D-Bus properties for Network1 ("d_network*"). */ + bool d_network_connected : 1; + + /* cached D-Bus properties for Adapter1 ("d_adapter*"). */ + bool d_adapter_powered : 1; + + /* properties related to device ("x_device*"). */ + NMBluetoothCapabilities x_device_connect_bt_type : 6; + bool x_device_is_usable : 1; + bool x_device_is_connected : 1; + + bool x_device_panu_connection_allow_create : 1; + + /* flag to remember last time when we checked wether the object + * was a suitable adapter that is usable to a device. */ + bool was_usable_adapter_for_device_before : 1; + + char _object_path_intern[]; +} BzDBusObj; + +typedef struct { + NMManager * manager; + NMSettings *settings; + + GDBusConnection *dbus_connection; + + NMBtVTableNetworkServer vtable_network_server; + + GCancellable *name_owner_get_cancellable; + GCancellable *get_managed_objects_cancellable; + + GHashTable *bzobjs; + + char *name_owner; + + GHashTable *conn_data_heads; + GHashTable *conn_data_elems; + + CList network_server_lst_head; + + CList process_change_lst_head; + + guint name_owner_changed_id; + + guint managed_objects_changed_id; + + guint properties_changed_id; + + guint process_change_idle_id; + + bool settings_registered : 1; +} NMBluezManagerPrivate; + +struct _NMBluezManager { + NMDeviceFactory parent; + NMBluezManagerPrivate _priv; +}; + +struct _NMBluezManagerClass { + NMDeviceFactoryClass parent; +}; + +G_DEFINE_TYPE(NMBluezManager, nm_bluez_manager, NM_TYPE_DEVICE_FACTORY); + +#define NM_BLUEZ_MANAGER_GET_PRIVATE(self) \ + _NM_GET_PRIVATE(self, NMBluezManager, NM_IS_BLUEZ_MANAGER) + +/*****************************************************************************/ + +NM_DEVICE_FACTORY_DECLARE_TYPES(NM_DEVICE_FACTORY_DECLARE_LINK_TYPES( + NM_LINK_TYPE_BNEP) NM_DEVICE_FACTORY_DECLARE_SETTING_TYPES(NM_SETTING_BLUETOOTH_SETTING_NAME)) + +G_MODULE_EXPORT NMDeviceFactory * + nm_device_factory_create(GError **error) +{ + return g_object_new(NM_TYPE_BLUEZ_MANAGER, NULL); +} + +/*****************************************************************************/ + +#define _NMLOG_DOMAIN LOGD_BT +#define _NMLOG(level, ...) __NMLOG_DEFAULT(level, _NMLOG_DOMAIN, "bluez", __VA_ARGS__) + +/*****************************************************************************/ + +static NMBluetoothCapabilities +convert_uuids_to_capabilities(const char *const *strv) +{ + NMBluetoothCapabilities capabilities = NM_BT_CAPABILITY_NONE; + + if (strv) { + for (; strv[0]; strv++) { + gs_free char *s_part1 = NULL; + const char * str = strv[0]; + const char * s; + + s = strchr(str, '-'); + if (!s) + continue; + + s_part1 = g_strndup(str, s - str); + switch (_nm_utils_ascii_str_to_int64(s_part1, 16, 0, G_MAXINT, -1)) { + case 0x1103: + capabilities |= NM_BT_CAPABILITY_DUN; + break; + case 0x1116: + capabilities |= NM_BT_CAPABILITY_NAP; + break; + default: + break; + } + } + } + + return capabilities; +} + +/*****************************************************************************/ + +static void _cleanup_for_name_owner(NMBluezManager *self); +static void _connect_disconnect(NMBluezManager *self, BzDBusObj *bzobj, const char *reason); +static gboolean _bzobjs_network_server_is_usable(const BzDBusObj *bzobj, gboolean require_powered); +static gboolean _bzobjs_is_dead(const BzDBusObj *bzobj); +static gboolean _bzobjs_device_is_usable(const BzDBusObj *bzobj, + BzDBusObj ** out_adapter_bzobj, + gboolean * out_create_panu_connection); +static gboolean _bzobjs_adapter_is_usable_for_device(const BzDBusObj *bzobj); +static ConnDataHead * +_conn_track_find_head(NMBluezManager *self, NMBluetoothCapabilities bt_type, const char *bdaddr); +static void _process_change_idle_schedule(NMBluezManager *self, BzDBusObj *bzobj); +static void +_network_server_unregister_bridge(NMBluezManager *self, BzDBusObj *bzobj, const char *reason); +static gboolean _connect_timeout_wait_connected_cb(gpointer user_data); + +/*****************************************************************************/ + +static void +_dbus_call_complete_cb_nop(GObject *source_object, GAsyncResult *res, gpointer user_data) +{ + /* we don't do anything at all. The only reason to register this + * callback is so that GDBusConnection keeps the cancellable alive + * long enough until the call completes. + * + * Note that this cancellable in turn is registered via + * nm_shutdown_wait_obj_register_*(), to block shutdown until + * we are done. */ +} + +/*****************************************************************************/ + +static void +_network_server_register_req_data_complete(NetworkServerRegisterReqData *r_req_data, GError *error) +{ + nm_clear_g_signal_handler(r_req_data->ext_cancellable, &r_req_data->ext_cancelled_id); + + nm_clear_g_cancellable(&r_req_data->int_cancellable); + + if (r_req_data->callback) { + gs_free_error GError *error_cancelled = NULL; + + if (g_cancellable_set_error_if_cancelled(r_req_data->ext_cancellable, &error_cancelled)) + error = error_cancelled; + + r_req_data->callback(error, r_req_data->callback_user_data); + } + + g_object_unref(r_req_data->ext_cancellable); + nm_g_slice_free(r_req_data); +} + +static void +_device_connect_req_data_complete(DeviceConnectReqData *c_req_data, + NMBluezManager * self, + const char * device_name, + GError * error) +{ + nm_assert((!!device_name) != (!!error)); + + nm_clear_g_signal_handler(c_req_data->ext_cancellable, &c_req_data->ext_cancelled_id); + + nm_clear_g_cancellable(&c_req_data->int_cancellable); + nm_clear_g_source(&c_req_data->timeout_id); + nm_clear_g_source(&c_req_data->timeout_wait_connect_id); + + if (c_req_data->callback) { + gs_free_error GError *error_cancelled = NULL; + + if (g_cancellable_set_error_if_cancelled(c_req_data->ext_cancellable, &error_cancelled)) { + error = error_cancelled; + device_name = NULL; + } + + c_req_data->callback(self, TRUE, device_name, error, c_req_data->callback_user_data); + } + + g_object_unref(c_req_data->ext_cancellable); + nm_clear_g_free(&c_req_data->device_name); + nm_g_slice_free(c_req_data); +} + +/*****************************************************************************/ + +static BzDBusObj * +_bz_dbus_obj_new(NMBluezManager *self, const char *object_path) +{ + BzDBusObj *bzobj; + gsize l; + + nm_assert(NM_IS_BLUEZ_MANAGER(self)); + + l = strlen(object_path) + 1; + + bzobj = g_malloc(sizeof(BzDBusObj) + l); + *bzobj = (BzDBusObj){ + .object_path = bzobj->_object_path_intern, + .self = self, + .x_network_server.lst = C_LIST_INIT(bzobj->x_network_server.lst), + .process_change_lst = C_LIST_INIT(bzobj->process_change_lst), + .x_device_panu_connection_allow_create = TRUE, + }; + memcpy(bzobj->_object_path_intern, object_path, l); + + return bzobj; +} + +static void +_bz_dbus_obj_free(BzDBusObj *bzobj) +{ + nm_assert(bzobj); + nm_assert(NM_IS_BLUEZ_MANAGER(bzobj->self)); + nm_assert(!bzobj->x_network_server.device_br); + nm_assert(!bzobj->x_network_server.r_req_data); + nm_assert(!bzobj->x_device.c_req_data); + + c_list_unlink_stale(&bzobj->process_change_lst); + c_list_unlink_stale(&bzobj->x_network_server.lst); + g_free(bzobj->x_network_server.adapter_address); + g_free(bzobj->d_adapter.address); + g_free(bzobj->d_network.interface); + g_free(bzobj->d_device.address); + g_free(bzobj->d_device.name); + g_free(bzobj->d_device.adapter); + g_free(bzobj); +} + +/*****************************************************************************/ + +static const char * +_bzobj_to_string(const BzDBusObj *bzobj, char *buf, gsize len) +{ + char * buf0 = buf; + const char *prefix = ""; + gboolean device_is_usable; + gboolean create_panu_connection = FALSE; + gboolean network_server_is_usable; + char sbuf_cap[100]; + + if (len > 0) + buf[0] = '\0'; + + if (bzobj->d_has_adapter_iface) { + nm_utils_strbuf_append_str(&buf, &len, prefix); + prefix = ", "; + nm_utils_strbuf_append_str(&buf, &len, "Adapter1 {"); + if (bzobj->d_adapter.address) { + nm_utils_strbuf_append(&buf, &len, " d.address: \"%s\"", bzobj->d_adapter.address); + if (bzobj->d_adapter_powered) + nm_utils_strbuf_append_str(&buf, &len, ","); + } + if (bzobj->d_adapter_powered) + nm_utils_strbuf_append(&buf, &len, " d.powered: 1"); + nm_utils_strbuf_append_str(&buf, &len, " }"); + } + + if (bzobj->d_has_device_iface) { + const char *prefix1 = ""; + + nm_utils_strbuf_append_str(&buf, &len, prefix); + prefix = ", "; + nm_utils_strbuf_append_str(&buf, &len, "Device1 {"); + if (bzobj->d_device.address) { + nm_utils_strbuf_append(&buf, + &len, + "%s d.address: \"%s\"", + prefix1, + bzobj->d_device.address); + prefix1 = ","; + } + if (bzobj->d_device.name) { + nm_utils_strbuf_append(&buf, &len, "%s d.name: \"%s\"", prefix1, bzobj->d_device.name); + prefix1 = ","; + } + if (bzobj->d_device.adapter) { + nm_utils_strbuf_append(&buf, + &len, + "%s d.adapter: \"%s\"", + prefix1, + bzobj->d_device.adapter); + prefix1 = ","; + } + if (bzobj->d_device_capabilities != NM_BT_CAPABILITY_NONE) { + nm_utils_strbuf_append(&buf, + &len, + "%s d.capabilities: \"%s\"", + prefix1, + nm_bluetooth_capability_to_string(bzobj->d_device_capabilities, + sbuf_cap, + sizeof(sbuf_cap))); + prefix1 = ","; + } + if (bzobj->d_device_connected) { + nm_utils_strbuf_append(&buf, &len, "%s d.connected: 1", prefix1); + prefix1 = ","; + } + if (bzobj->d_device_paired) { + nm_utils_strbuf_append(&buf, &len, "%s d.paired: 1", prefix1); + prefix1 = ","; + } + nm_utils_strbuf_append_str(&buf, &len, " }"); + } + + network_server_is_usable = _bzobjs_network_server_is_usable(bzobj, TRUE); + + if (bzobj->d_has_network_server_iface + || network_server_is_usable != (!c_list_is_empty(&bzobj->x_network_server.lst)) + || !c_list_is_empty(&bzobj->x_network_server.lst) + || !nm_streq0(bzobj->d_has_adapter_iface ? bzobj->d_adapter.address : NULL, + bzobj->x_network_server.adapter_address) + || bzobj->x_network_server.device_br || bzobj->x_network_server.r_req_data) { + nm_utils_strbuf_append_str(&buf, &len, prefix); + prefix = ", "; + + nm_utils_strbuf_append(&buf, &len, "NetworkServer1 { "); + + if (!bzobj->d_has_network_server_iface) + nm_utils_strbuf_append(&buf, &len, " has-d-iface: 0, "); + + if (network_server_is_usable != (!c_list_is_empty(&bzobj->x_network_server.lst))) + nm_utils_strbuf_append(&buf, + &len, + "usable: %d, used: %d", + !!network_server_is_usable, + !network_server_is_usable); + else if (network_server_is_usable) + nm_utils_strbuf_append(&buf, &len, "used: 1"); + else + nm_utils_strbuf_append(&buf, &len, "usable: 0"); + + if (!nm_streq0(bzobj->d_has_adapter_iface ? bzobj->d_adapter.address : NULL, + bzobj->x_network_server.adapter_address)) { + if (bzobj->x_network_server.adapter_address) + nm_utils_strbuf_append(&buf, + &len, + ", adapter-address: \"%s\"", + bzobj->x_network_server.adapter_address); + else + nm_utils_strbuf_append(&buf, &len, ", adapter-address: <NULL>"); + } + + if (bzobj->x_network_server.device_br) + nm_utils_strbuf_append(&buf, &len, ", bridge-device: 1"); + + if (bzobj->x_network_server.r_req_data) + nm_utils_strbuf_append(&buf, &len, ", register-in-progress: 1"); + + nm_utils_strbuf_append_str(&buf, &len, " }"); + } + + device_is_usable = _bzobjs_device_is_usable(bzobj, NULL, &create_panu_connection); + + if (bzobj->d_has_network_iface || bzobj->d_network.interface || bzobj->d_network_connected + || create_panu_connection || bzobj->x_device.panu_connection + || device_is_usable != bzobj->x_device_is_usable || bzobj->x_device.device_bt + || bzobj->x_device_connect_bt_type != NM_BT_CAPABILITY_NONE + || bzobj->x_device.connect_dun_context || bzobj->x_device.c_req_data + || bzobj->x_device_is_connected != bzobj->d_network_connected) { + nm_utils_strbuf_append_str(&buf, &len, prefix); + prefix = ", "; + nm_utils_strbuf_append_str(&buf, &len, "Network1 {"); + if (bzobj->d_network.interface) + nm_utils_strbuf_append(&buf, + &len, + " d.interface: \"%s\", ", + bzobj->d_network.interface); + if (bzobj->d_network_connected) + nm_utils_strbuf_append(&buf, &len, " d.connected: %d, ", !!bzobj->d_network_connected); + if (!bzobj->d_has_network_iface) + nm_utils_strbuf_append(&buf, &len, " has-d-iface: 0, "); + if (device_is_usable != bzobj->x_device_is_usable) + nm_utils_strbuf_append(&buf, + &len, + " usable: %d, used: %d", + !!device_is_usable, + !device_is_usable); + else if (device_is_usable) + nm_utils_strbuf_append(&buf, &len, " used: 1"); + else + nm_utils_strbuf_append(&buf, &len, " usable: 0"); + + if (create_panu_connection) + nm_utils_strbuf_append(&buf, &len, ", create-panu-connection: 1"); + + if (bzobj->x_device.panu_connection) + nm_utils_strbuf_append(&buf, &len, ", has-panu-connection: 1"); + + if (bzobj->x_device.device_bt) + nm_utils_strbuf_append(&buf, &len, ", has-device: 1"); + + if (bzobj->x_device_connect_bt_type != NM_BT_CAPABILITY_NONE + || bzobj->x_device.connect_dun_context) { + nm_utils_strbuf_append( + &buf, + &len, + ", connect: %s%s", + nm_bluetooth_capability_to_string(bzobj->x_device_connect_bt_type, + sbuf_cap, + sizeof(sbuf_cap)), + bzobj->x_device.connect_dun_context ? ",with-dun-context" : ""); + } + + if (bzobj->x_device.c_req_data) + nm_utils_strbuf_append(&buf, &len, ", connecting: 1"); + + if (bzobj->x_device_is_connected != bzobj->d_network_connected) + nm_utils_strbuf_append(&buf, &len, ", connected: %d", !!bzobj->x_device_is_connected); + + nm_utils_strbuf_append_str(&buf, &len, " }"); + } + + if (_bzobjs_is_dead(bzobj)) { + nm_utils_strbuf_append_str(&buf, &len, prefix); + prefix = ", "; + nm_utils_strbuf_append_str(&buf, &len, "dead: 1"); + } + + if (!c_list_is_empty(&bzobj->process_change_lst)) { + nm_utils_strbuf_append_str(&buf, &len, prefix); + prefix = ", "; + nm_utils_strbuf_append(&buf, &len, "change-pending-on-idle: 1"); + } + + if (_bzobjs_adapter_is_usable_for_device(bzobj) + != bzobj->was_usable_adapter_for_device_before) { + nm_utils_strbuf_append_str(&buf, &len, prefix); + prefix = ", "; + nm_utils_strbuf_append(&buf, &len, "change-usable-adapter-for-device: 1"); + } + + return buf0; +} + +#define _LOG_bzobj(bzobj, context) \ + G_STMT_START \ + { \ + const BzDBusObj *const _bzobj = (bzobj); \ + char _buf[500]; \ + \ + _LOGT("change %-21s %s : { %s }", \ + (context), \ + _bzobj->object_path, \ + _bzobj_to_string(_bzobj, _buf, sizeof(_buf))); \ + } \ + G_STMT_END + +static gboolean +_bzobjs_is_dead(const BzDBusObj *bzobj) +{ + return !bzobj->d_has_adapter_iface && !bzobj->d_has_device_iface && !bzobj->d_has_network_iface + && !bzobj->d_has_network_server_iface && c_list_is_empty(&bzobj->process_change_lst); +} + +static BzDBusObj * +_bzobjs_get(NMBluezManager *self, const char *object_path) +{ + return g_hash_table_lookup(NM_BLUEZ_MANAGER_GET_PRIVATE(self)->bzobjs, &object_path); +} + +static BzDBusObj * +_bzobjs_add(NMBluezManager *self, const char *object_path) +{ + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + BzDBusObj * bzobj; + + bzobj = _bz_dbus_obj_new(self, object_path); + if (!g_hash_table_add(priv->bzobjs, bzobj)) + nm_assert_not_reached(); + return bzobj; +} + +static void +_bzobjs_del(BzDBusObj *bzobj) +{ + nm_assert(bzobj); + nm_assert(bzobj == _bzobjs_get(bzobj->self, bzobj->object_path)); + + if (!g_hash_table_remove(NM_BLUEZ_MANAGER_GET_PRIVATE(bzobj->self)->bzobjs, bzobj)) + nm_assert_not_reached(); +} + +static void +_bzobjs_del_if_dead(BzDBusObj *bzobj) +{ + if (_bzobjs_is_dead(bzobj)) + _bzobjs_del(bzobj); +} + +static BzDBusObj * +_bzobjs_init(NMBluezManager *self, BzDBusObj **inout, const char *object_path) +{ + nm_assert(NM_IS_BLUEZ_MANAGER(self)); + nm_assert(object_path); + nm_assert(inout); + + if (!*inout) { + *inout = _bzobjs_get(self, object_path); + if (!*inout) + *inout = _bzobjs_add(self, object_path); + } + + nm_assert(nm_streq((*inout)->object_path, object_path)); + nm_assert(*inout == _bzobjs_get(self, object_path)); + return *inout; +} + +static gboolean +_bzobjs_adapter_is_usable_for_device(const BzDBusObj *bzobj) +{ + return bzobj->d_has_adapter_iface && bzobj->d_adapter.address && bzobj->d_adapter_powered; +} + +static gboolean +_bzobjs_device_is_usable(const BzDBusObj *bzobj, + BzDBusObj ** out_adapter_bzobj, + gboolean * out_create_panu_connection) +{ + NMBluezManager * self; + NMBluezManagerPrivate *priv; + gboolean usable_dun = FALSE; + gboolean usable_nap = FALSE; + BzDBusObj * bzobj_adapter; + gboolean create_panu_connection = FALSE; + + if (!bzobj->d_has_device_iface + || !NM_FLAGS_ANY((NMBluetoothCapabilities) bzobj->d_device_capabilities, + _NM_BT_CAPABILITY_SUPPORTED) + || !bzobj->d_device.name || !bzobj->d_device.address || !bzobj->d_device_paired + || !bzobj->d_device.adapter) + goto out_unusable; + + self = bzobj->self; + + priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + + if (!priv->settings_registered) + goto out_unusable; + + bzobj_adapter = _bzobjs_get(self, bzobj->d_device.adapter); + if (!bzobj_adapter || !_bzobjs_adapter_is_usable_for_device(bzobj_adapter)) + goto out_unusable; + +#if WITH_BLUEZ5_DUN + if (NM_FLAGS_HAS(bzobj->d_device_capabilities, NM_BT_CAPABILITY_DUN)) { + if (_conn_track_find_head(self, NM_BT_CAPABILITY_DUN, bzobj->d_device.address)) + usable_dun = TRUE; + } +#endif + + if (NM_FLAGS_HAS(bzobj->d_device_capabilities, NM_BT_CAPABILITY_NAP)) { + if (!bzobj->d_has_network_iface) + usable_nap = FALSE; + else if (_conn_track_find_head(self, NM_BT_CAPABILITY_NAP, bzobj->d_device.address)) + usable_nap = TRUE; + else if (bzobj->x_device_panu_connection_allow_create) { + /* We didn't yet try to create a connection. Presume we are going to create + * it when the time comes... */ + usable_nap = TRUE; + create_panu_connection = TRUE; + } + } + + if (!usable_dun && !usable_nap) { + if (bzobj->x_device.device_bt + && nm_device_get_state(NM_DEVICE(bzobj->x_device.device_bt)) + > NM_DEVICE_STATE_DISCONNECTED) { + /* The device is still activated... the absence of a profile does not + * render it unusable (yet). But since there is no more profile, the + * device is probably about to disconnect. */ + } else + goto out_unusable; + } + + NM_SET_OUT(out_create_panu_connection, create_panu_connection); + NM_SET_OUT(out_adapter_bzobj, bzobj_adapter); + return TRUE; + +out_unusable: + NM_SET_OUT(out_create_panu_connection, FALSE); + NM_SET_OUT(out_adapter_bzobj, NULL); + return FALSE; +} + +static gboolean +_bzobjs_device_is_connected(const BzDBusObj *bzobj) +{ + nm_assert(_bzobjs_device_is_usable(bzobj, NULL, NULL)); + + if (!bzobj->d_has_device_iface || !bzobj->d_device_connected) + return FALSE; + + if (bzobj->d_has_network_iface && bzobj->d_network_connected) + return TRUE; + if (bzobj->x_device.connect_dun_context) { + /* As long as we have a dun-context, we consider it connected. + * + * We require NMDeviceBt to try to connect to the modem, and if that fails, + * it will disconnect. */ + return TRUE; + } + return FALSE; +} + +static gboolean +_bzobjs_network_server_is_usable(const BzDBusObj *bzobj, gboolean require_powered) +{ + return bzobj->d_has_network_server_iface && bzobj->d_has_adapter_iface + && bzobj->d_adapter.address && (!require_powered || bzobj->d_adapter_powered); +} + +/*****************************************************************************/ + +static ConnDataHead * +_conn_data_head_new(NMBluetoothCapabilities bt_type, const char *bdaddr) +{ + ConnDataHead *cdata_hd; + gsize l; + + nm_assert(NM_IN_SET(bt_type, NM_BT_CAPABILITY_DUN, NM_BT_CAPABILITY_NAP)); + nm_assert(bdaddr); + + l = strlen(bdaddr) + 1; + cdata_hd = g_malloc(sizeof(ConnDataHead) + l); + *cdata_hd = (ConnDataHead){ + .bdaddr = cdata_hd->bdaddr_data, + .lst_head = C_LIST_INIT(cdata_hd->lst_head), + .bt_type = bt_type, + }; + memcpy(cdata_hd->bdaddr_data, bdaddr, l); + + nm_assert(cdata_hd->bt_type == bt_type); + + return cdata_hd; +} + +static guint +_conn_data_head_hash(gconstpointer ptr) +{ + const ConnDataHead *cdata_hd = ptr; + NMHashState h; + + nm_hash_init(&h, 520317467u); + nm_hash_update_val(&h, (NMBluetoothCapabilities) cdata_hd->bt_type); + nm_hash_update_str(&h, cdata_hd->bdaddr); + return nm_hash_complete(&h); +} + +static gboolean +_conn_data_head_equal(gconstpointer a, gconstpointer b) +{ + const ConnDataHead *cdata_hd_a = a; + const ConnDataHead *cdata_hd_b = b; + + return cdata_hd_a->bt_type == cdata_hd_b->bt_type + && nm_streq(cdata_hd_a->bdaddr, cdata_hd_b->bdaddr); +} + +static ConnDataHead * +_conn_track_find_head(NMBluezManager *self, NMBluetoothCapabilities bt_type, const char *bdaddr) +{ + ConnDataHead cdata_hd = { + .bt_type = bt_type, + .bdaddr = bdaddr, + }; + + return g_hash_table_lookup(NM_BLUEZ_MANAGER_GET_PRIVATE(self)->conn_data_heads, &cdata_hd); +} + +static ConnDataElem * +_conn_track_find_elem(NMBluezManager *self, NMSettingsConnection *sett_conn) +{ + G_STATIC_ASSERT(G_STRUCT_OFFSET(ConnDataElem, sett_conn) == 0); + + return g_hash_table_lookup(NM_BLUEZ_MANAGER_GET_PRIVATE(self)->conn_data_elems, &sett_conn); +} + +static gboolean +_conn_track_is_relevant_connection(NMConnection * connection, + NMBluetoothCapabilities *out_bt_type, + const char ** out_bdaddr) +{ + NMSettingBluetooth * s_bt; + NMBluetoothCapabilities bt_type; + const char * bdaddr; + const char * b_type; + + s_bt = nm_connection_get_setting_bluetooth(connection); + if (!s_bt) + return FALSE; + + if (!nm_connection_is_type(connection, NM_SETTING_BLUETOOTH_SETTING_NAME)) + return FALSE; + + bdaddr = nm_setting_bluetooth_get_bdaddr(s_bt); + if (!bdaddr) + return FALSE; + + b_type = nm_setting_bluetooth_get_connection_type(s_bt); + + if (nm_streq(b_type, NM_SETTING_BLUETOOTH_TYPE_DUN)) + bt_type = NM_BT_CAPABILITY_DUN; + else if (nm_streq(b_type, NM_SETTING_BLUETOOTH_TYPE_PANU)) + bt_type = NM_BT_CAPABILITY_NAP; + else + return FALSE; + + NM_SET_OUT(out_bt_type, bt_type); + NM_SET_OUT(out_bdaddr, bdaddr); + return TRUE; +} + +static gboolean +_conn_track_is_relevant_sett_conn(NMSettingsConnection * sett_conn, + NMBluetoothCapabilities *out_bt_type, + const char ** out_bdaddr) +{ + NMConnection *connection; + + connection = nm_settings_connection_get_connection(sett_conn); + if (!connection) + return FALSE; + + return _conn_track_is_relevant_connection(connection, out_bt_type, out_bdaddr); +} + +static gboolean +_conn_track_is_relevant_for_sett_conn(NMSettingsConnection * sett_conn, + NMBluetoothCapabilities bt_type, + const char * bdaddr) +{ + NMBluetoothCapabilities x_bt_type; + const char * x_bdaddr; + + return bdaddr && _conn_track_is_relevant_sett_conn(sett_conn, &x_bt_type, &x_bdaddr) + && x_bt_type == bt_type && nm_streq(x_bdaddr, bdaddr); +} + +static void +_conn_track_schedule_notify(NMBluezManager * self, + NMBluetoothCapabilities bt_type, + const char * bdaddr) +{ + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + GHashTableIter iter; + BzDBusObj * bzobj; + + g_hash_table_iter_init(&iter, priv->bzobjs); + while (g_hash_table_iter_next(&iter, (gpointer *) &bzobj, NULL)) { + gboolean device_is_usable; + + device_is_usable = _bzobjs_device_is_usable(bzobj, NULL, NULL); + if (bzobj->x_device_is_usable != device_is_usable) + _process_change_idle_schedule(self, bzobj); + } +} + +static void +_conn_track_update(NMBluezManager * self, + NMSettingsConnection *sett_conn, + gboolean track, + gboolean * out_changed, + gboolean * out_changed_usable, + ConnDataElem ** out_conn_data_elem) +{ + NMBluezManagerPrivate * priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + ConnDataHead * cdata_hd; + ConnDataElem * cdata_el; + ConnDataElem * cdata_el_remove = NULL; + NMBluetoothCapabilities bt_type; + const char * bdaddr; + gboolean changed = FALSE; + gboolean changed_usable = FALSE; + char sbuf_cap[100]; + + nm_assert(NM_IS_SETTINGS_CONNECTION(sett_conn)); + + cdata_el = _conn_track_find_elem(self, sett_conn); + + if (track) + track = _conn_track_is_relevant_sett_conn(sett_conn, &bt_type, &bdaddr); + + if (!track) { + cdata_el_remove = g_steal_pointer(&cdata_el); + goto out_remove; + } + + if (cdata_el) { + cdata_hd = cdata_el->cdata_hd; + if (cdata_hd->bt_type != bt_type || !nm_streq(cdata_hd->bdaddr, bdaddr)) + cdata_el_remove = g_steal_pointer(&cdata_el); + } + + if (!cdata_el) { + _LOGT("connection: track for %s, %s: %s (%s)", + nm_bluetooth_capability_to_string(bt_type, sbuf_cap, sizeof(sbuf_cap)), + bdaddr, + nm_settings_connection_get_uuid(sett_conn), + nm_settings_connection_get_id(sett_conn)); + changed = TRUE; + cdata_hd = _conn_track_find_head(self, bt_type, bdaddr); + if (!cdata_hd) { + changed_usable = TRUE; + cdata_hd = _conn_data_head_new(bt_type, bdaddr); + if (!g_hash_table_add(priv->conn_data_heads, cdata_hd)) + nm_assert_not_reached(); + _conn_track_schedule_notify(self, bt_type, bdaddr); + } + cdata_el = g_slice_new(ConnDataElem); + cdata_el->sett_conn = sett_conn; + cdata_el->cdata_hd = cdata_hd; + c_list_link_tail(&cdata_hd->lst_head, &cdata_el->lst); + if (!g_hash_table_add(priv->conn_data_elems, cdata_el)) + nm_assert_not_reached(); + } + +out_remove: + if (cdata_el_remove) { + GHashTableIter iter; + BzDBusObj * bzobj; + + _LOGT("connection: untrack for %s, %s: %s (%s)", + nm_bluetooth_capability_to_string(cdata_el_remove->cdata_hd->bt_type, + sbuf_cap, + sizeof(sbuf_cap)), + cdata_el_remove->cdata_hd->bdaddr, + nm_settings_connection_get_uuid(sett_conn), + nm_settings_connection_get_id(sett_conn)); + + g_hash_table_iter_init(&iter, priv->bzobjs); + while (g_hash_table_iter_next(&iter, (gpointer *) &bzobj, NULL)) { + if (bzobj->x_device.panu_connection == sett_conn) + bzobj->x_device.panu_connection = NULL; + } + + changed = TRUE; + cdata_hd = cdata_el_remove->cdata_hd; + c_list_unlink_stale(&cdata_el_remove->lst); + if (!g_hash_table_remove(priv->conn_data_elems, cdata_el_remove)) + nm_assert_not_reached(); + if (c_list_is_empty(&cdata_hd->lst_head)) { + changed_usable = TRUE; + _conn_track_schedule_notify(self, cdata_hd->bt_type, cdata_hd->bdaddr); + if (!g_hash_table_remove(priv->conn_data_heads, cdata_hd)) + nm_assert_not_reached(); + } + } + + NM_SET_OUT(out_changed, changed); + NM_SET_OUT(out_changed_usable, changed_usable); + NM_SET_OUT(out_conn_data_elem, cdata_el); +} + +/*****************************************************************************/ + +static void +cp_connection_added(NMSettings *settings, NMSettingsConnection *sett_conn, NMBluezManager *self) +{ + _conn_track_update(self, sett_conn, TRUE, NULL, NULL, NULL); +} + +static void +cp_connection_updated(NMSettings * settings, + NMSettingsConnection *sett_conn, + guint update_reason_u, + NMBluezManager * self) +{ + _conn_track_update(self, sett_conn, TRUE, NULL, NULL, NULL); +} + +static void +cp_connection_removed(NMSettings *settings, NMSettingsConnection *sett_conn, NMBluezManager *self) +{ + _conn_track_update(self, sett_conn, FALSE, NULL, NULL, NULL); +} + +/*****************************************************************************/ + +static NMBluezManager * +_network_server_get_bluez_manager(const NMBtVTableNetworkServer *vtable_network_server) +{ + NMBluezManager *self; + + self = (NMBluezManager *) (((char *) vtable_network_server) + - G_STRUCT_OFFSET(NMBluezManager, _priv.vtable_network_server)); + + g_return_val_if_fail(NM_IS_BLUEZ_MANAGER(self), NULL); + + return self; +} + +static BzDBusObj * +_network_server_find_has_device(NMBluezManagerPrivate *priv, NMDevice *device) +{ + BzDBusObj *bzobj; + + c_list_for_each_entry (bzobj, &priv->network_server_lst_head, x_network_server.lst) { + if (bzobj->x_network_server.device_br == device) + return bzobj; + } + return NULL; +} + +static BzDBusObj * +_network_server_find_available(NMBluezManagerPrivate *priv, + const char * addr, + NMDevice * device_accept_busy) +{ + BzDBusObj *bzobj; + + c_list_for_each_entry (bzobj, &priv->network_server_lst_head, x_network_server.lst) { + if (bzobj->x_network_server.device_br) { + if (bzobj->x_network_server.device_br != device_accept_busy) + continue; + } + if (addr && !nm_streq(addr, bzobj->d_adapter.address)) + continue; + nm_assert(!bzobj->x_network_server.r_req_data); + return bzobj; + } + return NULL; +} + +static gboolean +_network_server_vt_is_available(const NMBtVTableNetworkServer *vtable, + const char * addr, + NMDevice * device_accept_busy) +{ + NMBluezManager * self = _network_server_get_bluez_manager(vtable); + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + + return !!_network_server_find_available(priv, addr, device_accept_busy); +} + +static void +_network_server_register_cb(GObject *source_object, GAsyncResult *res, gpointer user_data) +{ + gs_unref_variant GVariant *ret = NULL; + gs_free_error GError *error = NULL; + BzDBusObj * bzobj; + + ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error); + if (!ret && nm_utils_error_is_cancelled(error)) + return; + + bzobj = user_data; + + if (!ret) { + _LOGT("NAP: [%s]: registering failed: %s", bzobj->object_path, error->message); + } else + _LOGT("NAP: [%s]: registration successful", bzobj->object_path); + + g_clear_object(&bzobj->x_network_server.r_req_data->int_cancellable); + _network_server_register_req_data_complete(g_steal_pointer(&bzobj->x_network_server.r_req_data), + error); +} + +static void +_network_server_register_cancelled_cb(GCancellable *cancellable, BzDBusObj *bzobj) +{ + _network_server_unregister_bridge(bzobj->self, bzobj, "registration cancelled"); +} + +static gboolean +_network_server_vt_register_bridge(const NMBtVTableNetworkServer *vtable, + const char * addr, + NMDevice * device, + GCancellable * cancellable, + NMBtVTableRegisterCallback callback, + gpointer callback_user_data, + GError ** error) +{ + NMBluezManager * self = _network_server_get_bluez_manager(vtable); + NMBluezManagerPrivate * priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + NetworkServerRegisterReqData *r_req_data; + BzDBusObj * bzobj; + const char * ifname; + + g_return_val_if_fail(NM_IS_DEVICE(device), FALSE); + g_return_val_if_fail(G_IS_CANCELLABLE(cancellable), FALSE); + + nm_assert(!g_cancellable_is_cancelled(cancellable)); + nm_assert(!_network_server_find_has_device(priv, device)); + + ifname = nm_device_get_iface(device); + g_return_val_if_fail(ifname, FALSE); + + g_return_val_if_fail(ifname, FALSE); + + bzobj = _network_server_find_available(priv, addr, NULL); + if (!bzobj) { + /* The device checked that a network server is available, before + * starting the activation, but for some reason it no longer is. + * Indicate that the activation should not proceed. */ + if (addr) { + nm_utils_error_set(error, + NM_UTILS_ERROR_UNKNOWN, + "adapter %s is not available for %s", + addr, + ifname); + } else { + nm_utils_error_set(error, + NM_UTILS_ERROR_UNKNOWN, + "no adapter available for %s", + ifname); + } + return FALSE; + } + + _LOGD("NAP: [%s]: registering \"%s\" on adapter %s", + bzobj->object_path, + ifname, + bzobj->d_adapter.address); + + r_req_data = g_slice_new(NetworkServerRegisterReqData); + *r_req_data = (NetworkServerRegisterReqData){ + .int_cancellable = g_cancellable_new(), + .ext_cancellable = g_object_ref(cancellable), + .callback = callback, + .callback_user_data = callback_user_data, + .ext_cancelled_id = g_signal_connect(cancellable, + "cancelled", + G_CALLBACK(_network_server_register_cancelled_cb), + bzobj), + }; + + bzobj->x_network_server.device_br = g_object_ref(device); + bzobj->x_network_server.r_req_data = r_req_data; + + g_dbus_connection_call(priv->dbus_connection, + priv->name_owner, + bzobj->object_path, + NM_BLUEZ5_NETWORK_SERVER_INTERFACE, + "Register", + g_variant_new("(ss)", BLUETOOTH_CONNECT_NAP, ifname), + NULL, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + bzobj->x_network_server.r_req_data->int_cancellable, + _network_server_register_cb, + bzobj); + return TRUE; +} + +static void +_network_server_unregister_bridge_complete_on_idle_cb(gpointer user_data, GCancellable *cancellable) +{ + gs_free_error GError * error = NULL; + gs_free char * reason = NULL; + NetworkServerRegisterReqData *r_req_data; + + nm_utils_user_data_unpack(user_data, &r_req_data, &reason); + + nm_utils_error_set(&error, + NM_UTILS_ERROR_UNKNOWN, + "registration was aborted due to %s", + reason); + _network_server_register_req_data_complete(r_req_data, error); +} + +static void +_network_server_unregister_bridge(NMBluezManager *self, BzDBusObj *bzobj, const char *reason) +{ + NMBluezManagerPrivate * priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + _nm_unused gs_unref_object NMDevice *device = NULL; + NetworkServerRegisterReqData * r_req_data; + + nm_assert(NM_IS_DEVICE(bzobj->x_network_server.device_br)); + + _LOGD("NAP: [%s]: unregistering \"%s\" (%s)", + bzobj->object_path, + nm_device_get_iface(bzobj->x_network_server.device_br), + reason); + + device = g_steal_pointer(&bzobj->x_network_server.device_br); + + r_req_data = g_steal_pointer(&bzobj->x_network_server.r_req_data); + + if (priv->name_owner) { + gs_unref_object GCancellable *cancellable = NULL; + + cancellable = g_cancellable_new(); + + nm_shutdown_wait_obj_register_cancellable_full( + cancellable, + g_strdup_printf("bt-unregister-nap[%s]", bzobj->object_path), + TRUE); + + g_dbus_connection_call(priv->dbus_connection, + priv->name_owner, + bzobj->object_path, + NM_BLUEZ5_NETWORK_SERVER_INTERFACE, + "Unregister", + g_variant_new("(s)", BLUETOOTH_CONNECT_NAP), + NULL, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + cancellable, + _dbus_call_complete_cb_nop, + NULL); + } + + if (r_req_data) { + nm_clear_g_cancellable(&r_req_data->int_cancellable); + nm_utils_invoke_on_idle(r_req_data->ext_cancellable, + _network_server_unregister_bridge_complete_on_idle_cb, + nm_utils_user_data_pack(r_req_data, g_strdup(reason))); + } + + _nm_device_bridge_notify_unregister_bt_nap(device, reason); +} + +static gboolean +_network_server_vt_unregister_bridge(const NMBtVTableNetworkServer *vtable, NMDevice *device) +{ + NMBluezManager * self = _network_server_get_bluez_manager(vtable); + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + BzDBusObj * bzobj; + + g_return_val_if_fail(NM_IS_DEVICE(device), FALSE); + + bzobj = _network_server_find_has_device(priv, device); + if (bzobj) + _network_server_unregister_bridge(self, bzobj, "disconnecting"); + + return TRUE; +} + +static void +_network_server_process_change(BzDBusObj *bzobj, gboolean *out_emit_device_availability_changed) +{ + NMBluezManager * self = bzobj->self; + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + gboolean network_server_is_usable; + gboolean emit_device_availability_changed = FALSE; + + network_server_is_usable = _bzobjs_network_server_is_usable(bzobj, TRUE); + + if (!network_server_is_usable) { + if (!c_list_is_empty(&bzobj->x_network_server.lst)) { + emit_device_availability_changed = TRUE; + c_list_unlink(&bzobj->x_network_server.lst); + } + + nm_clear_g_free(&bzobj->x_network_server.adapter_address); + + if (bzobj->x_network_server.device_br) { + _network_server_unregister_bridge(self, + bzobj, + _bzobjs_network_server_is_usable(bzobj, FALSE) + ? "adapter disabled" + : "adapter disappeared"); + } + + } else { + if (!nm_streq0(bzobj->x_network_server.adapter_address, bzobj->d_adapter.address)) { + emit_device_availability_changed = TRUE; + g_free(bzobj->x_network_server.adapter_address); + bzobj->x_network_server.adapter_address = g_strdup(bzobj->d_adapter.address); + } + + if (c_list_is_empty(&bzobj->x_network_server.lst)) { + emit_device_availability_changed = TRUE; + c_list_link_tail(&priv->network_server_lst_head, &bzobj->x_network_server.lst); + } + } + + if (emit_device_availability_changed) + NM_SET_OUT(out_emit_device_availability_changed, TRUE); +} + +/*****************************************************************************/ + +static void +_conn_create_panu_connection(NMBluezManager *self, BzDBusObj *bzobj) +{ + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + gs_unref_object NMConnection *connection = NULL; + NMSettingsConnection * added; + NMSetting * setting; + gs_free char * id = NULL; + char uuid[37]; + gs_free_error GError *error = NULL; + + nm_utils_uuid_generate_buf(uuid); + id = g_strdup_printf(_("%s Network"), bzobj->d_device.name); + + connection = nm_simple_connection_new(); + + setting = nm_setting_connection_new(); + g_object_set(setting, + NM_SETTING_CONNECTION_ID, + id, + NM_SETTING_CONNECTION_UUID, + uuid, + NM_SETTING_CONNECTION_AUTOCONNECT, + FALSE, + NM_SETTING_CONNECTION_TYPE, + NM_SETTING_BLUETOOTH_SETTING_NAME, + NULL); + nm_connection_add_setting(connection, setting); + + setting = nm_setting_bluetooth_new(); + g_object_set(setting, + NM_SETTING_BLUETOOTH_BDADDR, + bzobj->d_device.address, + NM_SETTING_BLUETOOTH_TYPE, + NM_SETTING_BLUETOOTH_TYPE_PANU, + NULL); + nm_connection_add_setting(connection, setting); + + if (!nm_connection_normalize(connection, NULL, NULL, &error)) { + _LOGE("connection: couldn't generate a connection for NAP device: %s", error->message); + g_return_if_reached(); + } + + nm_assert(_conn_track_is_relevant_connection(connection, NULL, NULL)); + + _LOGT("connection: create in-memory PANU connection %s (%s) for device \"%s\" (%s)", + uuid, + id, + bzobj->d_device.name, + bzobj->d_device.address); + + nm_settings_add_connection(priv->settings, + connection, + NM_SETTINGS_CONNECTION_PERSIST_MODE_IN_MEMORY_ONLY, + NM_SETTINGS_CONNECTION_ADD_REASON_NONE, + NM_SETTINGS_CONNECTION_INT_FLAGS_NM_GENERATED, + &added, + &error); + if (!added) { + _LOGW("connection: couldn't add new Bluetooth connection for NAP device: '%s' (%s): %s", + id, + uuid, + error->message); + return; + } + + if (!_conn_track_is_relevant_for_sett_conn(added, NM_BT_CAPABILITY_NAP, bzobj->d_device.address) + || !_conn_track_find_elem(self, added) || bzobj->x_device.panu_connection) { + _LOGE("connection: something went wrong creating PANU connection %s (%s) for device '%s'", + uuid, + id, + bzobj->d_device.address); + g_return_if_reached(); + } + + bzobj->x_device.panu_connection = added; +} + +/*****************************************************************************/ + +static void +_device_state_changed_cb(NMDevice *device, + guint new_state_u, + guint old_state_u, + guint reason_u, + gpointer user_data) +{ + BzDBusObj *bzobj = user_data; + + if (!_bzobjs_device_is_usable(bzobj, NULL, NULL)) { + /* the device got unusable? Need to revisit it... */ + _process_change_idle_schedule(bzobj->self, bzobj); + } +} + +static void +_device_process_change(BzDBusObj *bzobj) +{ + NMBluezManager *self = bzobj->self; + gs_unref_object NMDeviceBt *device_added = NULL; + gs_unref_object NMDeviceBt *device_deleted = NULL; + gboolean device_is_usable; + gboolean create_panu_connection = FALSE; + + device_is_usable = _bzobjs_device_is_usable(bzobj, NULL, &create_panu_connection); + + if (create_panu_connection) { + bzobj->x_device_panu_connection_allow_create = FALSE; + _conn_create_panu_connection(self, bzobj); + device_is_usable = _bzobjs_device_is_usable(bzobj, NULL, NULL); + } else { + if (device_is_usable && bzobj->x_device_panu_connection_allow_create + && NM_FLAGS_HAS(bzobj->d_device_capabilities, NM_BT_CAPABILITY_NAP) + && _conn_track_find_head(self, NM_BT_CAPABILITY_NAP, bzobj->d_device.address)) { + /* We have a useable device and also a panu-connection. We block future attemps + * to generate a connection. */ + bzobj->x_device_panu_connection_allow_create = FALSE; + } + if (bzobj->x_device.panu_connection) { + if (!NM_FLAGS_HAS(nm_settings_connection_get_flags(bzobj->x_device.panu_connection), + NM_SETTINGS_CONNECTION_INT_FLAGS_NM_GENERATED)) { + /* the connection that we generated earlier still exists, but it's not longer the same + * as it was when we created it. Forget about it, so that we don't delete the profile later... */ + bzobj->x_device.panu_connection = NULL; + } else { + if (!device_is_usable + || !_conn_track_is_relevant_for_sett_conn(bzobj->x_device.panu_connection, + NM_BT_CAPABILITY_NAP, + bzobj->d_device.address)) { + _LOGT("connection: delete in-memory PANU connection %s (%s) as device %s", + nm_settings_connection_get_uuid(bzobj->x_device.panu_connection), + nm_settings_connection_get_id(bzobj->x_device.panu_connection), + !device_is_usable ? "is now unusable" : "no longer matches"); + bzobj->x_device_panu_connection_allow_create = TRUE; + nm_settings_connection_delete(g_steal_pointer(&bzobj->x_device.panu_connection), + FALSE); + } + } + } + } + + bzobj->x_device_is_connected = device_is_usable && _bzobjs_device_is_connected(bzobj); + + bzobj->x_device_is_usable = device_is_usable; + + if (bzobj->x_device.device_bt) { + const char *device_to_delete_msg; + + if (!device_is_usable) + device_to_delete_msg = "device became unusable"; + else if (!_nm_device_bt_for_same_device(bzobj->x_device.device_bt, + bzobj->object_path, + bzobj->d_device.address, + NULL, + bzobj->d_device_capabilities)) + device_to_delete_msg = "device is no longer compatible"; + else + device_to_delete_msg = NULL; + + if (device_to_delete_msg) { + nm_clear_g_signal_handler(bzobj->x_device.device_bt, + &bzobj->x_device.device_bt_signal_id); + + device_deleted = g_steal_pointer(&bzobj->x_device.device_bt); + + _LOGD("[%s]: drop device because %s", bzobj->object_path, device_to_delete_msg); + + _connect_disconnect(self, bzobj, device_to_delete_msg); + } + } + + if (device_is_usable) { + if (!bzobj->x_device.device_bt) { + bzobj->x_device.device_bt = nm_device_bt_new(self, + bzobj->object_path, + bzobj->d_device.address, + bzobj->d_device.name, + bzobj->d_device_capabilities); + device_added = g_object_ref(bzobj->x_device.device_bt); + bzobj->x_device.device_bt_signal_id = + g_signal_connect(device_added, + NM_DEVICE_STATE_CHANGED, + G_CALLBACK(_device_state_changed_cb), + bzobj); + } else + _nm_device_bt_notify_set_name(bzobj->x_device.device_bt, bzobj->d_device.name); + + _nm_device_bt_notify_set_connected(bzobj->x_device.device_bt, bzobj->x_device_is_connected); + } + + if (bzobj->x_device.c_req_data && !bzobj->x_device.c_req_data->int_cancellable + && bzobj->x_device_is_connected) { + gs_free char *device_name = g_steal_pointer(&bzobj->x_device.c_req_data->device_name); + + _device_connect_req_data_complete(g_steal_pointer(&bzobj->x_device.c_req_data), + self, + device_name, + NULL); + } + + if (device_added) + g_signal_emit_by_name(self, NM_DEVICE_FACTORY_DEVICE_ADDED, device_added); + + if (device_deleted) + _nm_device_bt_notify_removed(device_deleted); +} + +/*****************************************************************************/ + +static void +_process_change_idle_all(NMBluezManager *self, gboolean *out_emit_device_availability_changed) +{ + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + BzDBusObj * bzobj; + + while ( + (bzobj = + c_list_first_entry(&priv->process_change_lst_head, BzDBusObj, process_change_lst))) { + c_list_unlink(&bzobj->process_change_lst); + + _LOG_bzobj(bzobj, "before-processing"); + + _device_process_change(bzobj); + + _network_server_process_change(bzobj, out_emit_device_availability_changed); + + _LOG_bzobj(bzobj, "after-processing"); + + _bzobjs_del_if_dead(bzobj); + } + + nm_clear_g_source(&priv->process_change_idle_id); +} + +static gboolean +_process_change_idle_cb(gpointer user_data) +{ + NMBluezManager * self = user_data; + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + gboolean emit_device_availability_changed = FALSE; + + _process_change_idle_all(self, &emit_device_availability_changed); + + if (emit_device_availability_changed) + nm_manager_notify_device_availability_maybe_changed(priv->manager); + + return G_SOURCE_CONTINUE; +} + +static void +_process_change_idle_schedule(NMBluezManager *self, BzDBusObj *bzobj) +{ + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + + nm_c_list_move_tail(&priv->process_change_lst_head, &bzobj->process_change_lst); + if (priv->process_change_idle_id == 0) + priv->process_change_idle_id = + g_idle_add_full(G_PRIORITY_DEFAULT_IDLE + 1, _process_change_idle_cb, self, NULL); +} + +static void +_dbus_process_changes(NMBluezManager *self, BzDBusObj *bzobj, const char *log_reason) +{ + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + gboolean network_server_is_usable; + gboolean adapter_is_usable_for_device; + gboolean device_is_usable; + gboolean changes = FALSE; + gboolean recheck_devices_for_adapter = FALSE; + + nm_assert(bzobj); + + _LOG_bzobj(bzobj, log_reason); + + device_is_usable = _bzobjs_device_is_usable(bzobj, NULL, NULL); + + if (bzobj->x_device_is_usable != device_is_usable) + changes = TRUE; + else if (bzobj->x_device.device_bt) { + if (!device_is_usable) + changes = TRUE; + else { + if (bzobj->x_device_is_connected != _bzobjs_device_is_connected(bzobj) + || !_nm_device_bt_for_same_device(bzobj->x_device.device_bt, + bzobj->object_path, + bzobj->d_device.address, + bzobj->d_device.name, + bzobj->d_device_capabilities)) + changes = TRUE; + } + } + + adapter_is_usable_for_device = _bzobjs_adapter_is_usable_for_device(bzobj); + if (adapter_is_usable_for_device != bzobj->was_usable_adapter_for_device_before) { + /* this function does not modify bzobj in any other cases except here. + * Usually changes are processed delayed, in the idle handler. + * + * But the bzobj->was_usable_adapter_for_device_before only exists to know whether + * we need to re-check device availability. It is correct to set the flag + * here, right before we checked. */ + bzobj->was_usable_adapter_for_device_before = adapter_is_usable_for_device; + recheck_devices_for_adapter = TRUE; + changes = TRUE; + } + + if (!changes) { + network_server_is_usable = _bzobjs_network_server_is_usable(bzobj, TRUE); + + if (network_server_is_usable != (!c_list_is_empty(&bzobj->x_network_server.lst))) + changes = TRUE; + else if (bzobj->x_network_server.device_br && !network_server_is_usable) + changes = TRUE; + else if (!nm_streq0(bzobj->d_has_adapter_iface ? bzobj->d_adapter.address : NULL, + bzobj->x_network_server.adapter_address)) + changes = TRUE; + } + + if (changes) + _process_change_idle_schedule(self, bzobj); + + if (recheck_devices_for_adapter) { + GHashTableIter iter; + BzDBusObj * bzobj2; + + /* we got a change to the availability of an adapter. We might need to recheck + * all devices that use this adapter... */ + g_hash_table_iter_init(&iter, priv->bzobjs); + while (g_hash_table_iter_next(&iter, (gpointer *) &bzobj2, NULL)) { + if (bzobj2 == bzobj) + continue; + if (!nm_streq0(bzobj2->d_device.adapter, bzobj->object_path)) + continue; + if (c_list_is_empty(&bzobj2->process_change_lst)) + _dbus_process_changes(self, bzobj2, "adapter-changed"); + else + nm_c_list_move_tail(&priv->process_change_lst_head, &bzobj2->process_change_lst); + } + } + + _bzobjs_del_if_dead(bzobj); +} + +/*****************************************************************************/ + +#define ALL_RELEVANT_INTERFACE_NAMES \ + NM_MAKE_STRV(NM_BLUEZ5_ADAPTER_INTERFACE, \ + NM_BLUEZ5_DEVICE_INTERFACE, \ + NM_BLUEZ5_NETWORK_INTERFACE, \ + NM_BLUEZ5_NETWORK_SERVER_INTERFACE) + +static gboolean +_dbus_handle_properties_changed(NMBluezManager * self, + const char * object_path, + const char * interface_name, + GVariant * changed_properties, + const char *const *invalidated_properties, + BzDBusObj ** inout_bzobj) +{ + BzDBusObj * bzobj = NULL; + gboolean changed = FALSE; + const char * property_name; + GVariant * property_value; + GVariantIter iter_prop; + gsize i; + + if (!invalidated_properties) + invalidated_properties = NM_PTRARRAY_EMPTY(const char *); + + nm_assert(g_variant_is_of_type(changed_properties, G_VARIANT_TYPE("a{sv}"))); + + if (inout_bzobj) { + bzobj = *inout_bzobj; + nm_assert(!bzobj || nm_streq(object_path, bzobj->object_path)); + } + + if (changed_properties) + g_variant_iter_init(&iter_prop, changed_properties); + + if (nm_streq(interface_name, NM_BLUEZ5_ADAPTER_INTERFACE)) { + _bzobjs_init(self, &bzobj, object_path); + if (!bzobj->d_has_adapter_iface) { + changed = TRUE; + bzobj->d_has_adapter_iface = TRUE; + } + + while (changed_properties + && g_variant_iter_next(&iter_prop, "{&sv}", &property_name, &property_value)) { + _nm_unused gs_unref_variant GVariant *property_value_free = property_value; + + if (nm_streq(property_name, "Address")) { + gs_free char *s = + g_variant_is_of_type(property_value, G_VARIANT_TYPE_STRING) + ? nm_utils_hwaddr_canonical(g_variant_get_string(property_value, NULL), + ETH_ALEN) + : NULL; + + if (!nm_streq0(bzobj->d_adapter.address, s)) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_adapter.address); + bzobj->d_adapter.address = g_steal_pointer(&s); + } + continue; + } + if (nm_streq(property_name, "Powered")) { + bool v = g_variant_is_of_type(property_value, G_VARIANT_TYPE_BOOLEAN) + && g_variant_get_boolean(property_value); + + if (bzobj->d_adapter_powered != v) { + changed = TRUE; + bzobj->d_adapter_powered = v; + } + continue; + } + } + + for (i = 0; (property_name = invalidated_properties[i]); i++) { + if (nm_streq(property_name, "Address")) { + if (bzobj->d_adapter.address) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_adapter.address); + } + continue; + } + if (nm_streq(property_name, "Powered")) { + if (bzobj->d_adapter_powered) { + changed = TRUE; + bzobj->d_adapter_powered = FALSE; + } + continue; + } + } + + } else if (nm_streq(interface_name, NM_BLUEZ5_DEVICE_INTERFACE)) { + _bzobjs_init(self, &bzobj, object_path); + if (!bzobj->d_has_device_iface) { + changed = TRUE; + bzobj->d_has_device_iface = TRUE; + } + + while (changed_properties + && g_variant_iter_next(&iter_prop, "{&sv}", &property_name, &property_value)) { + _nm_unused gs_unref_variant GVariant *property_value_free = property_value; + + if (nm_streq(property_name, "Address")) { + gs_free char *s = + g_variant_is_of_type(property_value, G_VARIANT_TYPE_STRING) + ? nm_utils_hwaddr_canonical(g_variant_get_string(property_value, NULL), + ETH_ALEN) + : NULL; + + if (!nm_streq0(bzobj->d_device.address, s)) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_device.address); + bzobj->d_device.address = g_steal_pointer(&s); + } + continue; + } + if (nm_streq(property_name, "Name")) { + const char *s = g_variant_is_of_type(property_value, G_VARIANT_TYPE_STRING) + ? g_variant_get_string(property_value, NULL) + : NULL; + + if (!nm_streq0(bzobj->d_device.name, s)) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_device.name); + bzobj->d_device.name = g_strdup(s); + } + continue; + } + if (nm_streq(property_name, "Adapter")) { + const char *s = g_variant_is_of_type(property_value, G_VARIANT_TYPE_OBJECT_PATH) + ? g_variant_get_string(property_value, NULL) + : NULL; + + if (!nm_streq0(bzobj->d_device.adapter, s)) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_device.adapter); + bzobj->d_device.adapter = g_strdup(s); + } + continue; + } + if (nm_streq(property_name, "UUIDs")) { + NMBluetoothCapabilities capabilities = NM_BT_CAPABILITY_NONE; + + if (g_variant_is_of_type(property_value, G_VARIANT_TYPE_STRING_ARRAY)) { + gs_free const char **s = g_variant_get_strv(property_value, NULL); + + capabilities = convert_uuids_to_capabilities(s); + } + if (bzobj->d_device_capabilities != capabilities) { + changed = TRUE; + bzobj->d_device_capabilities = capabilities; + nm_assert(bzobj->d_device_capabilities == capabilities); + } + continue; + } + if (nm_streq(property_name, "Connected")) { + bool v = g_variant_is_of_type(property_value, G_VARIANT_TYPE_BOOLEAN) + && g_variant_get_boolean(property_value); + + if (bzobj->d_device_connected != v) { + changed = TRUE; + bzobj->d_device_connected = v; + } + continue; + } + if (nm_streq(property_name, "Paired")) { + bool v = g_variant_is_of_type(property_value, G_VARIANT_TYPE_BOOLEAN) + && g_variant_get_boolean(property_value); + + if (bzobj->d_device_paired != v) { + changed = TRUE; + bzobj->d_device_paired = v; + } + continue; + } + } + + for (i = 0; (property_name = invalidated_properties[i]); i++) { + if (nm_streq(property_name, "Address")) { + if (bzobj->d_device.address) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_device.address); + } + continue; + } + if (nm_streq(property_name, "Name")) { + if (bzobj->d_device.name) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_device.name); + } + continue; + } + if (nm_streq(property_name, "Adapter")) { + if (bzobj->d_device.adapter) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_device.adapter); + } + continue; + } + if (nm_streq(property_name, "UUIDs")) { + if (bzobj->d_device_capabilities != NM_BT_CAPABILITY_NONE) { + changed = TRUE; + bzobj->d_device_capabilities = NM_BT_CAPABILITY_NONE; + } + continue; + } + if (nm_streq(property_name, "Connected")) { + if (bzobj->d_device_connected) { + changed = TRUE; + bzobj->d_device_connected = FALSE; + } + continue; + } + if (nm_streq(property_name, "Paired")) { + if (bzobj->d_device_paired) { + changed = TRUE; + bzobj->d_device_paired = FALSE; + } + continue; + } + } + + } else if (nm_streq(interface_name, NM_BLUEZ5_NETWORK_INTERFACE)) { + _bzobjs_init(self, &bzobj, object_path); + if (!bzobj->d_has_network_iface) { + changed = TRUE; + bzobj->d_has_network_iface = TRUE; + } + + while (changed_properties + && g_variant_iter_next(&iter_prop, "{&sv}", &property_name, &property_value)) { + _nm_unused gs_unref_variant GVariant *property_value_free = property_value; + + if (nm_streq(property_name, "Interface")) { + const char *s = g_variant_is_of_type(property_value, G_VARIANT_TYPE_STRING) + ? g_variant_get_string(property_value, NULL) + : NULL; + + if (!nm_streq0(bzobj->d_network.interface, s)) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_network.interface); + bzobj->d_network.interface = g_strdup(s); + } + continue; + } + if (nm_streq(property_name, "Connected")) { + bool v = g_variant_is_of_type(property_value, G_VARIANT_TYPE_BOOLEAN) + && g_variant_get_boolean(property_value); + + if (bzobj->d_network_connected != v) { + changed = TRUE; + bzobj->d_network_connected = v; + } + continue; + } + } + + for (i = 0; (property_name = invalidated_properties[i]); i++) { + if (nm_streq(property_name, "Interface")) { + if (bzobj->d_network.interface) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_network.interface); + } + continue; + } + if (nm_streq(property_name, "Connected")) { + if (bzobj->d_network_connected) { + changed = TRUE; + bzobj->d_network_connected = FALSE; + } + continue; + } + } + + } else if (nm_streq(interface_name, NM_BLUEZ5_NETWORK_SERVER_INTERFACE)) { + _bzobjs_init(self, &bzobj, object_path); + if (!bzobj->d_has_network_server_iface) { + changed = TRUE; + bzobj->d_has_network_server_iface = TRUE; + } + } + + nm_assert(!changed || bzobj); + + if (inout_bzobj) + *inout_bzobj = bzobj; + + return changed; +} + +static void +_dbus_handle_interface_added(NMBluezManager *self, + const char * object_path, + GVariant * ifaces, + gboolean initial_get_managed_objects) +{ + BzDBusObj * bzobj = NULL; + gboolean changed = FALSE; + const char * interface_name; + GVariant * changed_properties; + GVariantIter iter_ifaces; + + nm_assert(g_variant_is_of_type(ifaces, G_VARIANT_TYPE("a{sa{sv}}"))); + + g_variant_iter_init(&iter_ifaces, ifaces); + while (g_variant_iter_next(&iter_ifaces, "{&s@a{sv}}", &interface_name, &changed_properties)) { + _nm_unused gs_unref_variant GVariant *changed_properties_free = changed_properties; + + if (_dbus_handle_properties_changed(self, + object_path, + interface_name, + changed_properties, + NULL, + &bzobj)) + changed = TRUE; + } + + if (changed) { + _dbus_process_changes(self, + bzobj, + initial_get_managed_objects ? "dbus-init" : "dbus-iface-added"); + } +} + +static gboolean +_dbus_handle_interface_removed(NMBluezManager * self, + const char * object_path, + BzDBusObj ** inout_bzobj, + const char *const *removed_interfaces) +{ + gboolean changed = FALSE; + BzDBusObj *bzobj; + gsize i; + + if (inout_bzobj && *inout_bzobj) { + bzobj = *inout_bzobj; + nm_assert(bzobj == _bzobjs_get(self, object_path)); + } else { + bzobj = _bzobjs_get(self, object_path); + if (!bzobj) + return FALSE; + NM_SET_OUT(inout_bzobj, bzobj); + } + + for (i = 0; removed_interfaces[i]; i++) { + const char *interface_name = removed_interfaces[i]; + + if (nm_streq(interface_name, NM_BLUEZ5_ADAPTER_INTERFACE)) { + if (bzobj->d_has_adapter_iface) { + changed = TRUE; + bzobj->d_has_adapter_iface = FALSE; + } + if (bzobj->d_adapter.address) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_adapter.address); + } + if (bzobj->d_adapter_powered) { + changed = TRUE; + bzobj->d_adapter_powered = FALSE; + } + } else if (nm_streq(interface_name, NM_BLUEZ5_DEVICE_INTERFACE)) { + if (bzobj->d_has_device_iface) { + changed = TRUE; + bzobj->d_has_device_iface = FALSE; + } + if (bzobj->d_device.address) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_device.address); + } + if (bzobj->d_device.name) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_device.name); + } + if (bzobj->d_device.adapter) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_device.adapter); + } + if (bzobj->d_device_capabilities != NM_BT_CAPABILITY_NONE) { + changed = TRUE; + bzobj->d_device_capabilities = NM_BT_CAPABILITY_NONE; + } + if (bzobj->d_device_connected) { + changed = TRUE; + bzobj->d_device_connected = FALSE; + } + if (bzobj->d_device_paired) { + changed = TRUE; + bzobj->d_device_paired = FALSE; + } + } else if (nm_streq(interface_name, NM_BLUEZ5_NETWORK_INTERFACE)) { + if (bzobj->d_has_network_iface) { + changed = TRUE; + bzobj->d_has_network_iface = FALSE; + } + if (bzobj->d_network.interface) { + changed = TRUE; + nm_clear_g_free(&bzobj->d_network.interface); + } + if (bzobj->d_network_connected) { + changed = TRUE; + bzobj->d_network_connected = FALSE; + } + } else if (nm_streq(interface_name, NM_BLUEZ5_NETWORK_SERVER_INTERFACE)) { + if (bzobj->d_has_network_server_iface) { + changed = TRUE; + bzobj->d_has_network_server_iface = FALSE; + } + } + } + + return changed; +} + +static void +_dbus_managed_objects_changed_cb(GDBusConnection *connection, + const char * sender_name, + const char * arg_object_path, + const char * interface_name, + const char * signal_name, + GVariant * parameters, + gpointer user_data) +{ + NMBluezManager * self = user_data; + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + BzDBusObj * bzobj = NULL; + gboolean changed; + + nm_assert(nm_streq0(interface_name, DBUS_INTERFACE_OBJECT_MANAGER)); + + if (priv->get_managed_objects_cancellable) { + /* we still wait for the initial GetManagedObjects(). Ignore the event. */ + return; + } + + if (nm_streq(signal_name, "InterfacesAdded")) { + gs_unref_variant GVariant *interfaces_and_properties = NULL; + const char * object_path; + + if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oa{sa{sv}})"))) + return; + + g_variant_get(parameters, "(&o@a{sa{sv}})", &object_path, &interfaces_and_properties); + + _dbus_handle_interface_added(self, object_path, interfaces_and_properties, FALSE); + return; + } + + if (nm_streq(signal_name, "InterfacesRemoved")) { + gs_free const char **interfaces = NULL; + const char * object_path; + + if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oas)"))) + return; + + g_variant_get(parameters, "(&o^a&s)", &object_path, &interfaces); + + changed = _dbus_handle_interface_removed(self, object_path, &bzobj, interfaces); + if (changed) + _dbus_process_changes(self, bzobj, "dbus-iface-removed"); + return; + } +} + +static void +_dbus_properties_changed_cb(GDBusConnection *connection, + const char * sender_name, + const char * object_path, + const char * signal_interface_name, + const char * signal_name, + GVariant * parameters, + gpointer user_data) +{ + NMBluezManager * self = user_data; + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + const char * interface_name; + gs_unref_variant GVariant *changed_properties = NULL; + gs_free const char ** invalidated_properties = NULL; + BzDBusObj * bzobj = NULL; + + if (priv->get_managed_objects_cancellable) { + /* we still wait for the initial GetManagedObjects(). Ignore the event. */ + return; + } + + if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(sa{sv}as)"))) + return; + + g_variant_get(parameters, + "(&s@a{sv}^a&s)", + &interface_name, + &changed_properties, + &invalidated_properties); + + if (_dbus_handle_properties_changed(self, + object_path, + interface_name, + changed_properties, + invalidated_properties, + &bzobj)) + _dbus_process_changes(self, bzobj, "dbus-property-changed"); +} + +static void +_dbus_get_managed_objects_cb(GVariant *result, GError *error, gpointer user_data) +{ + NMBluezManager * self; + NMBluezManagerPrivate *priv; + GVariantIter iter; + const char * object_path; + GVariant * ifaces; + + if (!result && nm_utils_error_is_cancelled(error)) + return; + + self = user_data; + priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + + g_clear_object(&priv->get_managed_objects_cancellable); + + if (!result) { + _LOGT("initial GetManagedObjects() call failed: %s", error->message); + _cleanup_for_name_owner(self); + return; + } + + _LOGT("initial GetManagedObjects call succeeded"); + + g_variant_iter_init(&iter, result); + while (g_variant_iter_next(&iter, "{&o@a{sa{sv}}}", &object_path, &ifaces)) { + _nm_unused gs_unref_variant GVariant *ifaces_free = ifaces; + + _dbus_handle_interface_added(self, object_path, ifaces, TRUE); + } +} + +/*****************************************************************************/ + +static void +_cleanup_for_name_owner(NMBluezManager *self) +{ + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + gboolean emit_device_availability_changed = FALSE; + GHashTableIter iter; + BzDBusObj * bzobj; + gboolean first = TRUE; + + nm_clear_g_cancellable(&priv->get_managed_objects_cancellable); + + nm_clear_g_dbus_connection_signal(priv->dbus_connection, &priv->managed_objects_changed_id); + nm_clear_g_dbus_connection_signal(priv->dbus_connection, &priv->properties_changed_id); + + nm_clear_g_free(&priv->name_owner); + + g_hash_table_iter_init(&iter, priv->bzobjs); + while (g_hash_table_iter_next(&iter, (gpointer *) &bzobj, NULL)) { + if (first) { + first = FALSE; + _LOGT("drop all objects form D-Bus cache..."); + } + _dbus_handle_interface_removed(self, + bzobj->object_path, + &bzobj, + ALL_RELEVANT_INTERFACE_NAMES); + nm_c_list_move_tail(&priv->process_change_lst_head, &bzobj->process_change_lst); + } + _process_change_idle_all(self, &emit_device_availability_changed); + nm_assert(g_hash_table_size(priv->bzobjs) == 0); + + if (emit_device_availability_changed) + nm_manager_notify_device_availability_maybe_changed(priv->manager); +} + +static void +name_owner_changed(NMBluezManager *self, const char *owner) +{ + _nm_unused gs_unref_object NMBluezManager *self_keep_alive = g_object_ref(self); + NMBluezManagerPrivate * priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + + owner = nm_str_not_empty(owner); + + if (!owner) + _LOGT("D-Bus name for bluez has no owner"); + else + _LOGT("D-Bus name for bluez has owner %s", owner); + + nm_clear_g_cancellable(&priv->name_owner_get_cancellable); + + if (nm_streq0(priv->name_owner, owner)) + return; + + _cleanup_for_name_owner(self); + + if (!owner) + return; + + priv->name_owner = g_strdup(owner); + + priv->get_managed_objects_cancellable = g_cancellable_new(); + + priv->managed_objects_changed_id = + nm_dbus_connection_signal_subscribe_object_manager(priv->dbus_connection, + priv->name_owner, + NM_BLUEZ_MANAGER_PATH, + NULL, + _dbus_managed_objects_changed_cb, + self, + NULL); + + priv->properties_changed_id = + nm_dbus_connection_signal_subscribe_properties_changed(priv->dbus_connection, + priv->name_owner, + NULL, + NULL, + _dbus_properties_changed_cb, + self, + NULL); + + nm_dbus_connection_call_get_managed_objects(priv->dbus_connection, + priv->name_owner, + NM_BLUEZ_MANAGER_PATH, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + 20000, + priv->get_managed_objects_cancellable, + _dbus_get_managed_objects_cb, + self); +} + +static void +name_owner_changed_cb(GDBusConnection *connection, + const char * sender_name, + const char * object_path, + const char * interface_name, + const char * signal_name, + GVariant * parameters, + gpointer user_data) +{ + NMBluezManager *self = user_data; + const char * new_owner; + + if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(sss)"))) + return; + + g_variant_get(parameters, "(&s&s&s)", NULL, NULL, &new_owner); + + name_owner_changed(self, new_owner); +} + +static void +name_owner_get_cb(const char *name_owner, GError *error, gpointer user_data) +{ + if (name_owner || !g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) + name_owner_changed(user_data, name_owner); +} + +/*****************************************************************************/ + +static void +_cleanup_all(NMBluezManager *self) +{ + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + + priv->settings_registered = FALSE; + + g_signal_handlers_disconnect_by_func(priv->settings, cp_connection_added, self); + g_signal_handlers_disconnect_by_func(priv->settings, cp_connection_updated, self); + g_signal_handlers_disconnect_by_func(priv->settings, cp_connection_removed, self); + + g_hash_table_remove_all(priv->conn_data_elems); + g_hash_table_remove_all(priv->conn_data_heads); + + _cleanup_for_name_owner(self); + + nm_clear_g_cancellable(&priv->name_owner_get_cancellable); + + nm_clear_g_dbus_connection_signal(priv->dbus_connection, &priv->name_owner_changed_id); +} + +static void +start(NMDeviceFactory *factory) +{ + NMBluezManager * self; + NMBluezManagerPrivate * priv; + NMSettingsConnection *const *sett_conns; + guint n_sett_conns; + guint i; + + g_return_if_fail(NM_IS_BLUEZ_MANAGER(factory)); + + self = NM_BLUEZ_MANAGER(factory); + priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + + _cleanup_all(self); + + if (!priv->dbus_connection) { + _LOGI("no D-Bus connection available"); + return; + } + + g_signal_connect(priv->settings, + NM_SETTINGS_SIGNAL_CONNECTION_ADDED, + G_CALLBACK(cp_connection_added), + self); + g_signal_connect(priv->settings, + NM_SETTINGS_SIGNAL_CONNECTION_UPDATED, + G_CALLBACK(cp_connection_updated), + self); + g_signal_connect(priv->settings, + NM_SETTINGS_SIGNAL_CONNECTION_REMOVED, + G_CALLBACK(cp_connection_removed), + self); + + priv->settings_registered = TRUE; + + sett_conns = nm_settings_get_connections(priv->settings, &n_sett_conns); + for (i = 0; i < n_sett_conns; i++) + _conn_track_update(self, sett_conns[i], TRUE, NULL, NULL, NULL); + + priv->name_owner_changed_id = + nm_dbus_connection_signal_subscribe_name_owner_changed(priv->dbus_connection, + NM_BLUEZ_SERVICE, + name_owner_changed_cb, + self, + NULL); + + priv->name_owner_get_cancellable = g_cancellable_new(); + + nm_dbus_connection_call_get_name_owner(priv->dbus_connection, + NM_BLUEZ_SERVICE, + 10000, + priv->name_owner_get_cancellable, + name_owner_get_cb, + self); +} + +/*****************************************************************************/ + +static void +_connect_returned(NMBluezManager * self, + BzDBusObj * bzobj, + NMBluetoothCapabilities bt_type, + const char * device_name, + NMBluez5DunContext * dun_context, + GError * error) +{ + char sbuf_cap[100]; + + if (error) { + nm_assert(!device_name); + nm_assert(!dun_context); + + _LOGI("%s [%s]: connect failed: %s", + nm_bluetooth_capability_to_string(bzobj->x_device_connect_bt_type, + sbuf_cap, + sizeof(sbuf_cap)), + bzobj->object_path, + error->message); + + _device_connect_req_data_complete(g_steal_pointer(&bzobj->x_device.c_req_data), + self, + NULL, + error); + _connect_disconnect(self, bzobj, "cleanup after connect failure"); + return; + } + + nm_assert(bzobj->x_device_connect_bt_type == bt_type); + nm_assert(device_name); + nm_assert((bt_type == NM_BT_CAPABILITY_DUN) == (!!dun_context)); + nm_assert(bzobj->x_device.c_req_data); + + g_clear_object(&bzobj->x_device.c_req_data->int_cancellable); + + bzobj->x_device.connect_dun_context = dun_context; + + _LOGD("%s [%s]: connect successful to device %s", + nm_bluetooth_capability_to_string(bzobj->x_device_connect_bt_type, + sbuf_cap, + sizeof(sbuf_cap)), + bzobj->object_path, + device_name); + + /* we already have another over-all timer running. But after we connected the device, + * we still need to wait for bluez to acknowledge the connected state (via D-Bus, for NAP). + * For DUN profiles we likely are already fully connected by now. + * + * Anyway, schedule another timeout that is possibly shorter than the overall, original + * timeout. Now this should go down fast. */ + bzobj->x_device.c_req_data->timeout_wait_connect_id = + g_timeout_add(5000, _connect_timeout_wait_connected_cb, bzobj), + bzobj->x_device.c_req_data->device_name = g_strdup(device_name); + + if (_bzobjs_device_is_usable(bzobj, NULL, NULL) && _bzobjs_device_is_connected(bzobj)) { + /* We are now connected. Schedule the task that completes the state. */ + _process_change_idle_schedule(self, bzobj); + } +} + +#if WITH_BLUEZ5_DUN +static void +_connect_dun_notify_tty_hangup_cb(NMBluez5DunContext *context, gpointer user_data) +{ + BzDBusObj *bzobj = user_data; + + _connect_disconnect(bzobj->self, bzobj, "DUN connection hung up"); +} + +static void +_connect_dun_step2_cb(NMBluez5DunContext *context, + const char * rfcomm_dev, + GError * error, + gpointer user_data) +{ + BzDBusObj *bzobj; + + if (nm_utils_error_is_cancelled(error)) + return; + + bzobj = user_data; + + if (rfcomm_dev) { + /* We want to early notify about the rfcomm path. That is because we might still delay + * to signal full activation longer (asynchronously). But the earliest time the callback + * is invoked with the rfcomm path, we just created the device synchronously. + * + * By already notifying the caller about the path early, it avoids a race where ModemManager + * would find the modem before the bluetooth code considers the profile fully activated. */ + + nm_assert(!error); + nm_assert(bzobj->x_device.c_req_data); + + if (!g_cancellable_is_cancelled(bzobj->x_device.c_req_data->ext_cancellable)) + bzobj->x_device.c_req_data->callback(bzobj->self, + FALSE, + rfcomm_dev, + NULL, + bzobj->x_device.c_req_data->callback_user_data); + + if (!context) { + /* No context set. This means, we just got notified about the rfcomm path and need to wait + * longer, for the next callback. */ + return; + } + } + + _connect_returned(bzobj->self, bzobj, NM_BT_CAPABILITY_DUN, rfcomm_dev, context, error); +} + +static void +_connect_dun_step1_cb(GObject *source_object, GAsyncResult *res, gpointer user_data) +{ + gs_unref_variant GVariant *ret = NULL; + gs_free_error GError *error = NULL; + BzDBusObj * bzobj_adapter; + BzDBusObj * bzobj; + + ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error); + + if (!ret && nm_utils_error_is_cancelled(error)) + return; + + bzobj = user_data; + + if (error) { + _LOGT("DUN: [%s]: bluetooth device connect failed: %s", bzobj->object_path, error->message); + /* we actually ignore this error. Let's try, maybe we still can connect via DUN. */ + g_clear_error(&error); + } else + _LOGT("DUN: [%s]: bluetooth device connected successfully", bzobj->object_path); + + if (!_bzobjs_device_is_usable(bzobj, &bzobj_adapter, NULL)) { + nm_utils_error_set(&error, + NM_UTILS_ERROR_UNKNOWN, + "device %s is not usable for DUN after connect", + bzobj->object_path); + _connect_returned(bzobj->self, bzobj, NM_BT_CAPABILITY_DUN, NULL, NULL, error); + return; + } + + if (!nm_bluez5_dun_connect(bzobj_adapter->d_adapter.address, + bzobj->d_device.address, + bzobj->x_device.c_req_data->int_cancellable, + _connect_dun_step2_cb, + bzobj, + _connect_dun_notify_tty_hangup_cb, + bzobj, + &error)) { + _connect_returned(bzobj->self, bzobj, NM_BT_CAPABILITY_DUN, NULL, NULL, error); + return; + } +} +#endif + +static void +_connect_nap_cb(GObject *source_object, GAsyncResult *res, gpointer user_data) +{ + gs_unref_variant GVariant *ret = NULL; + const char * network_iface_name = NULL; + gs_free_error GError *error = NULL; + BzDBusObj * bzobj; + + ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source_object), res, &error); + + if (!ret && nm_utils_error_is_cancelled(error)) + return; + + if (ret) + g_variant_get(ret, "(&s)", &network_iface_name); + + bzobj = user_data; + + _connect_returned(bzobj->self, bzobj, NM_BT_CAPABILITY_NAP, network_iface_name, NULL, error); +} + +static void +_connect_cancelled_cb(GCancellable *cancellable, BzDBusObj *bzobj) +{ + _connect_disconnect(bzobj->self, bzobj, "connect cancelled"); +} + +static gboolean +_connect_timeout_wait_connected_cb(gpointer user_data) +{ + BzDBusObj *bzobj = user_data; + + bzobj->x_device.c_req_data->timeout_wait_connect_id = 0; + _connect_disconnect(bzobj->self, bzobj, "timeout waiting for connected"); + return G_SOURCE_REMOVE; +} + +static gboolean +_connect_timeout_cb(gpointer user_data) +{ + BzDBusObj *bzobj = user_data; + + bzobj->x_device.c_req_data->timeout_id = 0; + _connect_disconnect(bzobj->self, bzobj, "timeout connecting"); + return G_SOURCE_REMOVE; +} + +static void +_connect_disconnect(NMBluezManager *self, BzDBusObj *bzobj, const char *reason) +{ + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + DeviceConnectReqData * c_req_data; + char sbuf_cap[100]; + gboolean bt_type; + + if (bzobj->x_device_connect_bt_type == NM_BT_CAPABILITY_NONE) { + nm_assert(!bzobj->x_device.c_req_data); + return; + } + + bt_type = bzobj->x_device_connect_bt_type; + nm_assert(NM_IN_SET(bt_type, NM_BT_CAPABILITY_DUN, NM_BT_CAPABILITY_NAP)); + bzobj->x_device_connect_bt_type = NM_BT_CAPABILITY_NONE; + + c_req_data = g_steal_pointer(&bzobj->x_device.c_req_data); + + _LOGD("%s [%s]: disconnect due to %s", + nm_bluetooth_capability_to_string(bt_type, sbuf_cap, sizeof(sbuf_cap)), + bzobj->object_path, + reason); + + if (c_req_data) + nm_clear_g_cancellable(&c_req_data->int_cancellable); + + if (bt_type == NM_BT_CAPABILITY_DUN) { + /* For DUN devices, we also called org.bluez.Device1.Connect() (because in order + * for nm_bluez5_dun_connect() to succeed, we need to be already connected *why??). + * + * But upon disconnect we don't call Disconnect() because we don't know whether somebody + * else also uses the bluetooth device for other purposes. During disconnect we only + * terminate the DUN connection, but don't disconnect entirely. I think that's the + * best we can do. */ +#if WITH_BLUEZ5_DUN + nm_clear_pointer(&bzobj->x_device.connect_dun_context, nm_bluez5_dun_disconnect); +#else + nm_assert_not_reached(); +#endif + } else { + if (priv->name_owner) { + gs_unref_object GCancellable *cancellable = NULL; + + cancellable = g_cancellable_new(); + + nm_shutdown_wait_obj_register_cancellable_full( + cancellable, + g_strdup_printf("bt-disconnect-nap[%s]", bzobj->object_path), + TRUE); + + g_dbus_connection_call(priv->dbus_connection, + priv->name_owner, + bzobj->object_path, + NM_BLUEZ5_NETWORK_INTERFACE, + "Disconnect", + g_variant_new("()"), + NULL, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + cancellable, + _dbus_call_complete_cb_nop, + NULL); + } + } + + if (c_req_data) { + gs_free_error GError *error = NULL; + + nm_utils_error_set(&error, NM_UTILS_ERROR_UNKNOWN, "connect aborted due to %s", reason); + _device_connect_req_data_complete(c_req_data, self, NULL, error); + } +} + +gboolean +nm_bluez_manager_connect(NMBluezManager * self, + const char * object_path, + NMBluetoothCapabilities connection_bt_type, + int timeout_msec, + GCancellable * cancellable, + NMBluezManagerConnectCb callback, + gpointer callback_user_data, + GError ** error) +{ + gs_unref_object GCancellable *int_cancellable = NULL; + DeviceConnectReqData * c_req_data; + NMBluezManagerPrivate * priv; + BzDBusObj * bzobj; + char sbuf_cap[100]; + + g_return_val_if_fail(NM_IS_BLUEZ_MANAGER(self), FALSE); + g_return_val_if_fail(NM_IN_SET(connection_bt_type, NM_BT_CAPABILITY_DUN, NM_BT_CAPABILITY_NAP), + FALSE); + g_return_val_if_fail(callback, FALSE); + + nm_assert(timeout_msec > 0); + + priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + + bzobj = _bzobjs_get(self, object_path); + + if (!bzobj) { + nm_utils_error_set(error, NM_UTILS_ERROR_UNKNOWN, "device %s does not exist", object_path); + return FALSE; + } + + if (!_bzobjs_device_is_usable(bzobj, NULL, NULL)) { + nm_utils_error_set(error, NM_UTILS_ERROR_UNKNOWN, "device %s is not usable", object_path); + return FALSE; + } + + if (!NM_FLAGS_ALL(bzobj->d_device_capabilities, connection_bt_type)) { + nm_utils_error_set(error, + NM_UTILS_ERROR_UNKNOWN, + "device %s has not the required capabilities", + object_path); + return FALSE; + } + +#if !WITH_BLUEZ5_DUN + if (connection_bt_type == NM_BT_CAPABILITY_DUN) { + nm_utils_error_set(error, NM_UTILS_ERROR_UNKNOWN, "DUN is not supported"); + return FALSE; + } +#endif + + _connect_disconnect(self, bzobj, "new activation"); + + _LOGD("%s [%s]: connecting...", + nm_bluetooth_capability_to_string(connection_bt_type, sbuf_cap, sizeof(sbuf_cap)), + bzobj->object_path); + + int_cancellable = g_cancellable_new(); + +#if WITH_BLUEZ5_DUN + if (connection_bt_type == NM_BT_CAPABILITY_DUN) { + g_dbus_connection_call(priv->dbus_connection, + priv->name_owner, + bzobj->object_path, + NM_BLUEZ5_DEVICE_INTERFACE, + "Connect", + NULL, + NULL, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + timeout_msec, + int_cancellable, + _connect_dun_step1_cb, + bzobj); + } else +#endif + { + nm_assert(connection_bt_type == NM_BT_CAPABILITY_NAP); + g_dbus_connection_call(priv->dbus_connection, + priv->name_owner, + bzobj->object_path, + NM_BLUEZ5_NETWORK_INTERFACE, + "Connect", + g_variant_new("(s)", BLUETOOTH_CONNECT_NAP), + G_VARIANT_TYPE("(s)"), + G_DBUS_CALL_FLAGS_NO_AUTO_START, + timeout_msec, + int_cancellable, + _connect_nap_cb, + bzobj); + } + + c_req_data = g_slice_new(DeviceConnectReqData); + *c_req_data = (DeviceConnectReqData){ + .int_cancellable = g_steal_pointer(&int_cancellable), + .ext_cancellable = g_object_ref(cancellable), + .callback = callback, + .callback_user_data = callback_user_data, + .ext_cancelled_id = + g_signal_connect(cancellable, "cancelled", G_CALLBACK(_connect_cancelled_cb), bzobj), + .timeout_id = g_timeout_add(timeout_msec, _connect_timeout_cb, bzobj), + }; + + bzobj->x_device_connect_bt_type = connection_bt_type; + bzobj->x_device.c_req_data = c_req_data; + + return TRUE; +} + +void +nm_bluez_manager_disconnect(NMBluezManager *self, const char *object_path) +{ + BzDBusObj *bzobj; + + g_return_if_fail(NM_IS_BLUEZ_MANAGER(self)); + g_return_if_fail(object_path); + + bzobj = _bzobjs_get(self, object_path); + if (!bzobj) + return; + + _connect_disconnect(self, bzobj, "disconnected by user"); +} + +/*****************************************************************************/ + +static NMDevice * +create_device(NMDeviceFactory * factory, + const char * iface, + const NMPlatformLink *plink, + NMConnection * connection, + gboolean * out_ignore) +{ + *out_ignore = TRUE; + g_return_val_if_fail(plink->type == NM_LINK_TYPE_BNEP, NULL); + return NULL; +} + +static gboolean +match_connection(NMDeviceFactory *factory, NMConnection *connection) +{ + const char *type = nm_connection_get_connection_type(connection); + + nm_assert(nm_streq(type, NM_SETTING_BLUETOOTH_SETTING_NAME)); + + if (_nm_connection_get_setting_bluetooth_for_nap(connection)) + return FALSE; /* handled by the bridge factory */ + + return TRUE; +} + +/*****************************************************************************/ + +static void +nm_bluez_manager_init(NMBluezManager *self) +{ + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + + priv->vtable_network_server = (NMBtVTableNetworkServer){ + .is_available = _network_server_vt_is_available, + .register_bridge = _network_server_vt_register_bridge, + .unregister_bridge = _network_server_vt_unregister_bridge, + }; + + c_list_init(&priv->network_server_lst_head); + c_list_init(&priv->process_change_lst_head); + + priv->conn_data_heads = + g_hash_table_new_full(_conn_data_head_hash, _conn_data_head_equal, g_free, NULL); + priv->conn_data_elems = g_hash_table_new_full(nm_pdirect_hash, + nm_pdirect_equal, + nm_g_slice_free_fcn(ConnDataElem), + NULL); + + priv->bzobjs = g_hash_table_new_full(nm_pstr_hash, + nm_pstr_equal, + (GDestroyNotify) _bz_dbus_obj_free, + NULL); + + priv->manager = g_object_ref(NM_MANAGER_GET); + priv->settings = g_object_ref(NM_SETTINGS_GET); + priv->dbus_connection = nm_g_object_ref(NM_MAIN_DBUS_CONNECTION_GET); + + g_atomic_pointer_compare_and_exchange(&nm_bt_vtable_network_server, + NULL, + &priv->vtable_network_server); +} + +static void +dispose(GObject *object) +{ + NMBluezManager * self = NM_BLUEZ_MANAGER(object); + NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self); + + /* FIXME(shutdown): we need a nm_device_factory_stop() hook to first unregister all + * BzDBusObj instances and do necessary cleanup actions (like disconnecting devices + * or deleting panu_connection). */ + + nm_assert(c_list_is_empty(&priv->network_server_lst_head)); + nm_assert(c_list_is_empty(&priv->process_change_lst_head)); + nm_assert(priv->process_change_idle_id == 0); + + g_atomic_pointer_compare_and_exchange(&nm_bt_vtable_network_server, + &priv->vtable_network_server, + NULL); + + _cleanup_all(self); + + G_OBJECT_CLASS(nm_bluez_manager_parent_class)->dispose(object); + + g_clear_object(&priv->settings); + g_clear_object(&priv->manager); + g_clear_object(&priv->dbus_connection); + + nm_clear_pointer(&priv->bzobjs, g_hash_table_destroy); +} + +static void +nm_bluez_manager_class_init(NMBluezManagerClass *klass) +{ + GObjectClass * object_class = G_OBJECT_CLASS(klass); + NMDeviceFactoryClass *factory_class = NM_DEVICE_FACTORY_CLASS(klass); + + object_class->dispose = dispose; + + factory_class->get_supported_types = get_supported_types; + factory_class->create_device = create_device; + factory_class->match_connection = match_connection; + factory_class->start = start; +} |