New upstream version 1.35.91 upstream/1.35.91

7 files changed, 307 insertions, 342 deletions

diff --git a/src/core/devices/bluetooth/nm-bluez-manager.c b/src/core/devices/bluetooth/nm-bluez-manager.c
index 36e442ad..05f85297 100644
--- a/src/core/devices/bluetooth/nm-bluez-manager.c
+++ b/src/core/devices/bluetooth/nm-bluez-manager.c
@@ -38,7 +38,7 @@
 #define _NM_BT_CAPABILITY_SUPPORTED (NM_BT_CAPABILITY_NAP | _NM_BT_CAPABILITY_SUPPORTED_DUN)
 
 typedef struct {
-    const char *            bdaddr;
+    const char             *bdaddr;
     CList                   lst_head;
     NMBluetoothCapabilities bt_type : 8;
     char                    bdaddr_data[];
@@ -46,24 +46,24 @@ typedef struct {
 
 typedef struct {
     NMSettingsConnection *sett_conn;
-    ConnDataHead *        cdata_hd;
+    ConnDataHead         *cdata_hd;
     CList                 lst;
 } ConnDataElem;
 
 typedef struct {
-    GCancellable *             ext_cancellable;
-    GCancellable *             int_cancellable;
+    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;
+    GCancellable           *ext_cancellable;
+    GCancellable           *int_cancellable;
     NMBluezManagerConnectCb callback;
     gpointer                callback_user_data;
-    char *                  device_name;
+    char                   *device_name;
     gulong                  ext_cancelled_id;
     guint                   timeout_id;
     guint                   timeout_wait_connect_id;
@@ -97,16 +97,16 @@ typedef struct {
 
     struct {
         CList                         lst;
-        char *                        adapter_address;
-        NMDevice *                    device_br;
+        char                         *adapter_address;
+        NMDevice                     *device_br;
         NetworkServerRegisterReqData *r_req_data;
     } x_network_server;
 
     struct {
         NMSettingsConnection *panu_connection;
-        NMDeviceBt *          device_bt;
+        NMDeviceBt           *device_bt;
         DeviceConnectReqData *c_req_data;
-        NMBluez5DunContext *  connect_dun_context;
+        NMBluez5DunContext   *connect_dun_context;
         gulong                device_bt_signal_id;
     } x_device;
 
@@ -142,7 +142,7 @@ typedef struct {
 } BzDBusObj;
 
 typedef struct {
-    NMManager * manager;
+    NMManager  *manager;
     NMSettings *settings;
 
     GDBusConnection *dbus_connection;
@@ -194,7 +194,7 @@ 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)
+nm_device_factory_create(GError **error)
 {
     return g_object_new(NM_TYPE_BLUEZ_MANAGER, NULL);
 }
@@ -214,8 +214,8 @@ convert_uuids_to_capabilities(const char *const *strv)
     if (strv) {
         for (; strv[0]; strv++) {
             gs_free char *s_part1 = NULL;
-            const char *  str     = strv[0];
-            const char *  s;
+            const char   *str     = strv[0];
+            const char   *s;
 
             s = strchr(str, '-');
             if (!s)
@@ -245,8 +245,8 @@ static void     _connect_disconnect(NMBluezManager *self, BzDBusObj *bzobj, cons
 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);
+                                         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);
@@ -293,9 +293,9 @@ _network_server_register_req_data_complete(NetworkServerRegisterReqData *r_req_d
 
 static void
 _device_connect_req_data_complete(DeviceConnectReqData *c_req_data,
-                                  NMBluezManager *      self,
-                                  const char *          device_name,
-                                  GError *              error)
+                                  NMBluezManager       *self,
+                                  const char           *device_name,
+                                  GError               *error)
 {
     nm_assert((!!device_name) != (!!error));
 
@@ -371,7 +371,7 @@ _bz_dbus_obj_free(BzDBusObj *bzobj)
 static const char *
 _bzobj_to_string(const BzDBusObj *bzobj, char *buf, gsize len)
 {
-    char *      buf0   = buf;
+    char       *buf0   = buf;
     const char *prefix = "";
     gboolean    device_is_usable;
     gboolean    create_panu_connection = FALSE;
@@ -591,7 +591,7 @@ static BzDBusObj *
 _bzobjs_add(NMBluezManager *self, const char *object_path)
 {
     NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
-    BzDBusObj *            bzobj;
+    BzDBusObj             *bzobj;
 
     bzobj = _bz_dbus_obj_new(self, object_path);
     if (!g_hash_table_add(priv->bzobjs, bzobj))
@@ -642,14 +642,14 @@ _bzobjs_adapter_is_usable_for_device(const BzDBusObj *bzobj)
 
 static gboolean
 _bzobjs_device_is_usable(const BzDBusObj *bzobj,
-                         BzDBusObj **     out_adapter_bzobj,
-                         gboolean *       out_create_panu_connection)
+                         BzDBusObj      **out_adapter_bzobj,
+                         gboolean        *out_create_panu_connection)
 {
-    NMBluezManager *       self;
+    NMBluezManager        *self;
     NMBluezManagerPrivate *priv;
     gboolean               usable_dun = FALSE;
     gboolean               usable_nap = FALSE;
-    BzDBusObj *            bzobj_adapter;
+    BzDBusObj             *bzobj_adapter;
     gboolean               create_panu_connection = FALSE;
 
     if (!bzobj->d_has_device_iface
@@ -805,14 +805,14 @@ _conn_track_find_elem(NMBluezManager *self, NMSettingsConnection *sett_conn)
 }
 
 static gboolean
-_conn_track_is_relevant_connection(NMConnection *           connection,
+_conn_track_is_relevant_connection(NMConnection            *connection,
                                    NMBluetoothCapabilities *out_bt_type,
-                                   const char **            out_bdaddr)
+                                   const char             **out_bdaddr)
 {
-    NMSettingBluetooth *    s_bt;
+    NMSettingBluetooth     *s_bt;
     NMBluetoothCapabilities bt_type;
-    const char *            bdaddr;
-    const char *            b_type;
+    const char             *bdaddr;
+    const char             *b_type;
 
     s_bt = nm_connection_get_setting_bluetooth(connection);
     if (!s_bt)
@@ -840,9 +840,9 @@ _conn_track_is_relevant_connection(NMConnection *           connection,
 }
 
 static gboolean
-_conn_track_is_relevant_sett_conn(NMSettingsConnection *   sett_conn,
+_conn_track_is_relevant_sett_conn(NMSettingsConnection    *sett_conn,
                                   NMBluetoothCapabilities *out_bt_type,
-                                  const char **            out_bdaddr)
+                                  const char             **out_bdaddr)
 {
     NMConnection *connection;
 
@@ -854,25 +854,25 @@ _conn_track_is_relevant_sett_conn(NMSettingsConnection *   sett_conn,
 }
 
 static gboolean
-_conn_track_is_relevant_for_sett_conn(NMSettingsConnection *  sett_conn,
+_conn_track_is_relevant_for_sett_conn(NMSettingsConnection   *sett_conn,
                                       NMBluetoothCapabilities bt_type,
-                                      const char *            bdaddr)
+                                      const char             *bdaddr)
 {
     NMBluetoothCapabilities x_bt_type;
-    const char *            x_bdaddr;
+    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,
+_conn_track_schedule_notify(NMBluezManager         *self,
                             NMBluetoothCapabilities bt_type,
-                            const char *            bdaddr)
+                            const char             *bdaddr)
 {
     NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
     GHashTableIter         iter;
-    BzDBusObj *            bzobj;
+    BzDBusObj             *bzobj;
 
     g_hash_table_iter_init(&iter, priv->bzobjs);
     while (g_hash_table_iter_next(&iter, (gpointer *) &bzobj, NULL)) {
@@ -885,19 +885,19 @@ _conn_track_schedule_notify(NMBluezManager *        self,
 }
 
 static void
-_conn_track_update(NMBluezManager *      self,
+_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;
+                   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;
+    const char             *bdaddr;
     gboolean                changed        = FALSE;
     gboolean                changed_usable = FALSE;
     char                    sbuf_cap[100];
@@ -946,7 +946,7 @@ _conn_track_update(NMBluezManager *      self,
 out_remove:
     if (cdata_el_remove) {
         GHashTableIter iter;
-        BzDBusObj *    bzobj;
+        BzDBusObj     *bzobj;
 
         _LOGT("connection: untrack for %s, %s: %s (%s)",
               nm_bluetooth_capability_to_string(cdata_el_remove->cdata_hd->bt_type,
@@ -989,10 +989,10 @@ cp_connection_added(NMSettings *settings, NMSettingsConnection *sett_conn, NMBlu
 }
 
 static void
-cp_connection_updated(NMSettings *          settings,
+cp_connection_updated(NMSettings           *settings,
                       NMSettingsConnection *sett_conn,
                       guint                 update_reason_u,
-                      NMBluezManager *      self)
+                      NMBluezManager       *self)
 {
     _conn_track_update(self, sett_conn, TRUE, NULL, NULL, NULL);
 }
@@ -1032,8 +1032,8 @@ _network_server_find_has_device(NMBluezManagerPrivate *priv, NMDevice *device)
 
 static BzDBusObj *
 _network_server_find_available(NMBluezManagerPrivate *priv,
-                               const char *           addr,
-                               NMDevice *             device_accept_busy)
+                               const char            *addr,
+                               NMDevice              *device_accept_busy)
 {
     BzDBusObj *bzobj;
 
@@ -1052,10 +1052,10 @@ _network_server_find_available(NMBluezManagerPrivate *priv,
 
 static gboolean
 _network_server_vt_is_available(const NMBtVTableNetworkServer *vtable,
-                                const char *                   addr,
-                                NMDevice *                     device_accept_busy)
+                                const char                    *addr,
+                                NMDevice                      *device_accept_busy)
 {
-    NMBluezManager *       self = _network_server_get_bluez_manager(vtable);
+    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);
@@ -1064,9 +1064,9 @@ _network_server_vt_is_available(const NMBtVTableNetworkServer *vtable,
 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;
+    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))
@@ -1092,18 +1092,18 @@ _network_server_register_cancelled_cb(GCancellable *cancellable, BzDBusObj *bzob
 
 static gboolean
 _network_server_vt_register_bridge(const NMBtVTableNetworkServer *vtable,
-                                   const char *                   addr,
-                                   NMDevice *                     device,
-                                   GCancellable *                 cancellable,
+                                   const char                    *addr,
+                                   NMDevice                      *device,
+                                   GCancellable                  *cancellable,
                                    NMBtVTableRegisterCallback     callback,
                                    gpointer                       callback_user_data,
-                                   GError **                      error)
+                                   GError                       **error)
 {
-    NMBluezManager *              self = _network_server_get_bluez_manager(vtable);
-    NMBluezManagerPrivate *       priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
+    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;
+    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);
@@ -1174,8 +1174,8 @@ _network_server_vt_register_bridge(const NMBtVTableNetworkServer *vtable,
 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;
+    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);
@@ -1190,9 +1190,9 @@ _network_server_unregister_bridge_complete_on_idle_cb(gpointer user_data, GCance
 static void
 _network_server_unregister_bridge(NMBluezManager *self, BzDBusObj *bzobj, const char *reason)
 {
-    NMBluezManagerPrivate *    priv             = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
+    NMBluezManagerPrivate               *priv   = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
     _nm_unused gs_unref_object NMDevice *device = NULL;
-    NetworkServerRegisterReqData *       r_req_data;
+    NetworkServerRegisterReqData        *r_req_data;
 
     nm_assert(NM_IS_DEVICE(bzobj->x_network_server.device_br));
 
@@ -1242,9 +1242,9 @@ _network_server_unregister_bridge(NMBluezManager *self, BzDBusObj *bzobj, const
 static gboolean
 _network_server_vt_unregister_bridge(const NMBtVTableNetworkServer *vtable, NMDevice *device)
 {
-    NMBluezManager *       self = _network_server_get_bluez_manager(vtable);
+    NMBluezManager        *self = _network_server_get_bluez_manager(vtable);
     NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
-    BzDBusObj *            bzobj;
+    BzDBusObj             *bzobj;
 
     g_return_val_if_fail(NM_IS_DEVICE(device), FALSE);
 
@@ -1258,7 +1258,7 @@ _network_server_vt_unregister_bridge(const NMBtVTableNetworkServer *vtable, NMDe
 static void
 _network_server_process_change(BzDBusObj *bzobj, gboolean *out_emit_device_availability_changed)
 {
-    NMBluezManager *       self = bzobj->self;
+    NMBluezManager        *self = bzobj->self;
     NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
     gboolean               network_server_is_usable;
     gboolean               emit_device_availability_changed = FALSE;
@@ -1303,13 +1303,13 @@ _network_server_process_change(BzDBusObj *bzobj, gboolean *out_emit_device_avail
 static void
 _conn_create_panu_connection(NMBluezManager *self, BzDBusObj *bzobj)
 {
-    NMBluezManagerPrivate *priv              = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
+    NMBluezManagerPrivate        *priv       = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
     gs_unref_object NMConnection *connection = NULL;
-    NMSettingsConnection *        added;
-    NMSetting *                   setting;
-    gs_free char *                id = NULL;
+    NMSettingsConnection         *added;
+    NMSetting                    *setting;
+    gs_free char                 *id = NULL;
     char                          uuid[37];
-    gs_free_error GError *error = NULL;
+    gs_free_error GError         *error = NULL;
 
     nm_uuid_generate_random_str_arr(uuid);
     id = g_strdup_printf(_("%s Network"), bzobj->d_device.name);
@@ -1398,7 +1398,7 @@ _device_state_changed_cb(NMDevice *device,
 static void
 _device_process_change(BzDBusObj *bzobj)
 {
-    NMBluezManager *self                       = bzobj->self;
+    NMBluezManager             *self           = bzobj->self;
     gs_unref_object NMDeviceBt *device_added   = NULL;
     gs_unref_object NMDeviceBt *device_deleted = NULL;
     gboolean                    device_is_usable;
@@ -1513,7 +1513,7 @@ static void
 _process_change_idle_all(NMBluezManager *self, gboolean *out_emit_device_availability_changed)
 {
     NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
-    BzDBusObj *            bzobj;
+    BzDBusObj             *bzobj;
 
     while (
         (bzobj =
@@ -1537,7 +1537,7 @@ _process_change_idle_all(NMBluezManager *self, gboolean *out_emit_device_availab
 static gboolean
 _process_change_idle_cb(gpointer user_data)
 {
-    NMBluezManager *       self                             = user_data;
+    NMBluezManager        *self                             = user_data;
     NMBluezManagerPrivate *priv                             = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
     gboolean               emit_device_availability_changed = FALSE;
 
@@ -1622,7 +1622,7 @@ _dbus_process_changes(NMBluezManager *self, BzDBusObj *bzobj, const char *log_re
 
     if (recheck_devices_for_adapter) {
         GHashTableIter iter;
-        BzDBusObj *    bzobj2;
+        BzDBusObj     *bzobj2;
 
         /* we got a change to the availability of an adapter. We might need to recheck
          * all devices that use this adapter... */
@@ -1651,17 +1651,17 @@ _dbus_process_changes(NMBluezManager *self, BzDBusObj *bzobj, const char *log_re
                  NM_BLUEZ5_NETWORK_SERVER_INTERFACE)
 
 static gboolean
-_dbus_handle_properties_changed(NMBluezManager *   self,
-                                const char *       object_path,
-                                const char *       interface_name,
-                                GVariant *         changed_properties,
+_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        **inout_bzobj)
 {
-    BzDBusObj *  bzobj   = NULL;
+    BzDBusObj   *bzobj   = NULL;
     gboolean     changed = FALSE;
-    const char * property_name;
-    GVariant *   property_value;
+    const char  *property_name;
+    GVariant    *property_value;
     GVariantIter iter_prop;
     gsize        i;
 
@@ -1933,14 +1933,14 @@ _dbus_handle_properties_changed(NMBluezManager *   self,
 
 static void
 _dbus_handle_interface_added(NMBluezManager *self,
-                             const char *    object_path,
-                             GVariant *      ifaces,
+                             const char     *object_path,
+                             GVariant       *ifaces,
                              gboolean        initial_get_managed_objects)
 {
-    BzDBusObj *  bzobj   = NULL;
+    BzDBusObj   *bzobj   = NULL;
     gboolean     changed = FALSE;
-    const char * interface_name;
-    GVariant *   changed_properties;
+    const char  *interface_name;
+    GVariant    *changed_properties;
     GVariantIter iter_ifaces;
 
     nm_assert(g_variant_is_of_type(ifaces, G_VARIANT_TYPE("a{sa{sv}}")));
@@ -1966,9 +1966,9 @@ _dbus_handle_interface_added(NMBluezManager *self,
 }
 
 static gboolean
-_dbus_handle_interface_removed(NMBluezManager *   self,
-                               const char *       object_path,
-                               BzDBusObj **       inout_bzobj,
+_dbus_handle_interface_removed(NMBluezManager    *self,
+                               const char        *object_path,
+                               BzDBusObj        **inout_bzobj,
                                const char *const *removed_interfaces)
 {
     gboolean   changed = FALSE;
@@ -2056,16 +2056,16 @@ _dbus_handle_interface_removed(NMBluezManager *   self,
 
 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,
+                                 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;
+    NMBluezManager        *self  = user_data;
     NMBluezManagerPrivate *priv  = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
-    BzDBusObj *            bzobj = NULL;
+    BzDBusObj             *bzobj = NULL;
     gboolean               changed;
 
     nm_assert(nm_streq0(interface_name, DBUS_INTERFACE_OBJECT_MANAGER));
@@ -2077,7 +2077,7 @@ _dbus_managed_objects_changed_cb(GDBusConnection *connection,
 
     if (nm_streq(signal_name, "InterfacesAdded")) {
         gs_unref_variant GVariant *interfaces_and_properties = NULL;
-        const char *               object_path;
+        const char                *object_path;
 
         if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oa{sa{sv}})")))
             return;
@@ -2090,7 +2090,7 @@ _dbus_managed_objects_changed_cb(GDBusConnection *connection,
 
     if (nm_streq(signal_name, "InterfacesRemoved")) {
         gs_free const char **interfaces = NULL;
-        const char *         object_path;
+        const char          *object_path;
 
         if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oas)")))
             return;
@@ -2106,19 +2106,19 @@ _dbus_managed_objects_changed_cb(GDBusConnection *connection,
 
 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,
+                            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;
+    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;
+    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. */
@@ -2146,11 +2146,11 @@ _dbus_properties_changed_cb(GDBusConnection *connection,
 static void
 _dbus_get_managed_objects_cb(GVariant *result, GError *error, gpointer user_data)
 {
-    NMBluezManager *       self;
+    NMBluezManager        *self;
     NMBluezManagerPrivate *priv;
     GVariantIter           iter;
-    const char *           object_path;
-    GVariant *             ifaces;
+    const char            *object_path;
+    GVariant              *ifaces;
 
     if (!result && nm_utils_error_is_cancelled(error))
         return;
@@ -2184,7 +2184,7 @@ _cleanup_for_name_owner(NMBluezManager *self)
     NMBluezManagerPrivate *priv                             = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
     gboolean               emit_device_availability_changed = FALSE;
     GHashTableIter         iter;
-    BzDBusObj *            bzobj;
+    BzDBusObj             *bzobj;
     gboolean               first = TRUE;
 
     nm_clear_g_cancellable(&priv->get_managed_objects_cancellable);
@@ -2217,7 +2217,7 @@ 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);
+    NMBluezManagerPrivate                     *priv            = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
 
     owner = nm_str_not_empty(owner);
 
@@ -2270,15 +2270,15 @@ name_owner_changed(NMBluezManager *self, const char *owner)
 
 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,
+                      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;
+    const char     *new_owner;
 
     if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(sss)")))
         return;
@@ -2321,8 +2321,8 @@ _cleanup_all(NMBluezManager *self)
 static void
 start(NMDeviceFactory *factory)
 {
-    NMBluezManager *             self;
-    NMBluezManagerPrivate *      priv;
+    NMBluezManager              *self;
+    NMBluezManagerPrivate       *priv;
     NMSettingsConnection *const *sett_conns;
     guint                        n_sett_conns;
     guint                        i;
@@ -2378,12 +2378,12 @@ start(NMDeviceFactory *factory)
 /*****************************************************************************/
 
 static void
-_connect_returned(NMBluezManager *        self,
-                  BzDBusObj *             bzobj,
+_connect_returned(NMBluezManager         *self,
+                  BzDBusObj              *bzobj,
                   NMBluetoothCapabilities bt_type,
-                  const char *            device_name,
-                  NMBluez5DunContext *    dun_context,
-                  GError *                error)
+                  const char             *device_name,
+                  NMBluez5DunContext     *dun_context,
+                  GError                 *error)
 {
     char sbuf_cap[100];
 
@@ -2449,8 +2449,8 @@ _connect_dun_notify_tty_hangup_cb(NMBluez5DunContext *context, gpointer user_dat
 
 static void
 _connect_dun_step2_cb(NMBluez5DunContext *context,
-                      const char *        rfcomm_dev,
-                      GError *            error,
+                      const char         *rfcomm_dev,
+                      GError             *error,
                       gpointer            user_data)
 {
     BzDBusObj *bzobj;
@@ -2491,10 +2491,10 @@ _connect_dun_step2_cb(NMBluez5DunContext *context,
 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;
+    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);
 
@@ -2537,9 +2537,9 @@ 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;
+    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);
 
@@ -2584,7 +2584,7 @@ static void
 _connect_disconnect(NMBluezManager *self, BzDBusObj *bzobj, const char *reason)
 {
     NMBluezManagerPrivate *priv = NM_BLUEZ_MANAGER_GET_PRIVATE(self);
-    DeviceConnectReqData * c_req_data;
+    DeviceConnectReqData  *c_req_data;
     char                   sbuf_cap[100];
     gboolean               bt_type;
 
@@ -2655,19 +2655,19 @@ _connect_disconnect(NMBluezManager *self, BzDBusObj *bzobj, const char *reason)
 }
 
 gboolean
-nm_bluez_manager_connect(NMBluezManager *        self,
-                         const char *            object_path,
+nm_bluez_manager_connect(NMBluezManager         *self,
+                         const char             *object_path,
                          NMBluetoothCapabilities connection_bt_type,
                          int                     timeout_msec,
-                         GCancellable *          cancellable,
+                         GCancellable           *cancellable,
                          NMBluezManagerConnectCb callback,
                          gpointer                callback_user_data,
-                         GError **               error)
+                         GError                **error)
 {
     gs_unref_object GCancellable *int_cancellable = NULL;
-    DeviceConnectReqData *        c_req_data;
-    NMBluezManagerPrivate *       priv;
-    BzDBusObj *                   bzobj;
+    DeviceConnectReqData         *c_req_data;
+    NMBluezManagerPrivate        *priv;
+    BzDBusObj                    *bzobj;
     char                          sbuf_cap[100];
 
     g_return_val_if_fail(NM_IS_BLUEZ_MANAGER(self), FALSE);
@@ -2781,11 +2781,11 @@ nm_bluez_manager_disconnect(NMBluezManager *self, const char *object_path)
 /*****************************************************************************/
 
 static NMDevice *
-create_device(NMDeviceFactory *     factory,
-              const char *          iface,
+create_device(NMDeviceFactory      *factory,
+              const char           *iface,
               const NMPlatformLink *plink,
-              NMConnection *        connection,
-              gboolean *            out_ignore)
+              NMConnection         *connection,
+              gboolean             *out_ignore)
 {
     *out_ignore = TRUE;
     g_return_val_if_fail(plink->type == NM_LINK_TYPE_BNEP, NULL);
@@ -2845,7 +2845,7 @@ nm_bluez_manager_init(NMBluezManager *self)
 static void
 dispose(GObject *object)
 {
-    NMBluezManager *       self = NM_BLUEZ_MANAGER(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
@@ -2877,7 +2877,7 @@ dispose(GObject *object)
 static void
 nm_bluez_manager_class_init(NMBluezManagerClass *klass)
 {
-    GObjectClass *        object_class  = G_OBJECT_CLASS(klass);
+    GObjectClass         *object_class  = G_OBJECT_CLASS(klass);
     NMDeviceFactoryClass *factory_class = NM_DEVICE_FACTORY_CLASS(klass);
 
     object_class->dispose = dispose;
diff --git a/src/core/devices/bluetooth/nm-bluez-manager.h b/src/core/devices/bluetooth/nm-bluez-manager.h
index 04bfea7d..299f5c3b 100644
--- a/src/core/devices/bluetooth/nm-bluez-manager.h
+++ b/src/core/devices/bluetooth/nm-bluez-manager.h
@@ -24,18 +24,18 @@ GType nm_bluez_manager_get_type(void);
 typedef void (*NMBluezManagerConnectCb)(
     NMBluezManager *self,
     gboolean        is_completed /* or else is early notification with DUN path */,
-    const char *    device_name,
-    GError *        error,
+    const char     *device_name,
+    GError         *error,
     gpointer        user_data);
 
-gboolean nm_bluez_manager_connect(NMBluezManager *        self,
-                                  const char *            object_path,
+gboolean nm_bluez_manager_connect(NMBluezManager         *self,
+                                  const char             *object_path,
                                   NMBluetoothCapabilities connection_bt_type,
                                   int                     timeout_msec,
-                                  GCancellable *          cancellable,
+                                  GCancellable           *cancellable,
                                   NMBluezManagerConnectCb callback,
                                   gpointer                callback_user_data,
-                                  GError **               error);
+                                  GError                **error);
 
 void nm_bluez_manager_disconnect(NMBluezManager *self, const char *object_path);
 
diff --git a/src/core/devices/bluetooth/nm-bluez5-dun.c b/src/core/devices/bluetooth/nm-bluez5-dun.c
index 7efbfaf4..426bab0c 100644
--- a/src/core/devices/bluetooth/nm-bluez5-dun.c
+++ b/src/core/devices/bluetooth/nm-bluez5-dun.c
@@ -23,7 +23,7 @@
 /*****************************************************************************/
 
 typedef struct {
-    GCancellable *       cancellable;
+    GCancellable        *cancellable;
     NMBluez5DunConnectCb callback;
     gpointer             callback_user_data;
 
@@ -265,10 +265,10 @@ _connect_create_rfcomm(NMBluez5DunContext *context)
 static gboolean
 _connect_socket_connect_cb(int fd, GIOCondition condition, gpointer user_data)
 {
-    NMBluez5DunContext *context = user_data;
-    gs_free_error GError *error = NULL;
-    int                   errsv = 0;
-    socklen_t             slen  = sizeof(errsv);
+    NMBluez5DunContext   *context = user_data;
+    gs_free_error GError *error   = NULL;
+    int                   errsv   = 0;
+    socklen_t             slen    = sizeof(errsv);
     int                   r;
 
     nm_clear_g_source_inst(&context->cdat->source);
@@ -415,7 +415,7 @@ _connect_sdp_search_cb(uint8_t type, uint16_t status, uint8_t *rsp, size_t size,
     do {
         sdp_record_t *rec;
         int           recsize = 0;
-        sdp_list_t *  protos;
+        sdp_list_t   *protos;
 
         rec = sdp_extract_pdu(rsp, bytesleft, &recsize);
         if (!rec)
@@ -454,8 +454,8 @@ _connect_sdp_search_cb(uint8_t type, uint16_t status, uint8_t *rsp, size_t size,
 static gboolean
 _connect_sdp_search_io_cb(int fd, GIOCondition condition, gpointer user_data)
 {
-    NMBluez5DunContext *context = user_data;
-    gs_free_error GError *error = NULL;
+    NMBluez5DunContext   *context = user_data;
+    gs_free_error GError *error   = NULL;
     int                   errsv;
 
     if (condition & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) {
@@ -505,8 +505,8 @@ _connect_sdp_search_io_cb(int fd, GIOCondition condition, gpointer user_data)
 static gboolean
 _connect_sdp_session_start_on_idle_cb(gpointer user_data)
 {
-    NMBluez5DunContext *context = user_data;
-    gs_free_error GError *error = NULL;
+    NMBluez5DunContext   *context = user_data;
+    gs_free_error GError *error   = NULL;
 
     nm_clear_g_source_inst(&context->cdat->source);
 
@@ -521,15 +521,15 @@ _connect_sdp_session_start_on_idle_cb(gpointer user_data)
 static gboolean
 _connect_sdp_io_cb(int fd, GIOCondition condition, gpointer user_data)
 {
-    NMBluez5DunContext *context = user_data;
-    sdp_list_t *        search;
-    sdp_list_t *        attrs;
-    uuid_t              svclass;
-    uint16_t            attr;
-    int                 errsv;
-    int                 fd_err = 0;
-    int                 r;
-    socklen_t           len     = sizeof(fd_err);
+    NMBluez5DunContext   *context = user_data;
+    sdp_list_t           *search;
+    sdp_list_t           *attrs;
+    uuid_t                svclass;
+    uint16_t              attr;
+    int                   errsv;
+    int                   fd_err = 0;
+    int                   r;
+    socklen_t             len   = sizeof(fd_err);
     gs_free_error GError *error = NULL;
 
     nm_clear_g_source_inst(&context->cdat->source);
@@ -657,17 +657,17 @@ _connect_sdp_session_start(NMBluez5DunContext *context, GError **error)
 /*****************************************************************************/
 
 gboolean
-nm_bluez5_dun_connect(const char *                 adapter,
-                      const char *                 remote,
-                      GCancellable *               cancellable,
+nm_bluez5_dun_connect(const char                  *adapter,
+                      const char                  *remote,
+                      GCancellable                *cancellable,
                       NMBluez5DunConnectCb         callback,
                       gpointer                     callback_user_data,
                       NMBluez5DunNotifyTtyHangupCb notify_tty_hangup_cb,
                       gpointer                     notify_tty_hangup_user_data,
-                      GError **                    error)
+                      GError                     **error)
 {
     nm_auto_free_context NMBluez5DunContext *context = NULL;
-    ConnectData *                            cdat;
+    ConnectData                             *cdat;
     gsize                                    src_l;
     gsize                                    dst_l;
 
diff --git a/src/core/devices/bluetooth/nm-bluez5-dun.h b/src/core/devices/bluetooth/nm-bluez5-dun.h
index 020d4119..72ca1380 100644
--- a/src/core/devices/bluetooth/nm-bluez5-dun.h
+++ b/src/core/devices/bluetooth/nm-bluez5-dun.h
@@ -11,20 +11,20 @@ typedef struct _NMBluez5DunContext NMBluez5DunContext;
 #if WITH_BLUEZ5_DUN
 
 typedef void (*NMBluez5DunConnectCb)(NMBluez5DunContext *context,
-                                     const char *        rfcomm_dev,
-                                     GError *            error,
+                                     const char         *rfcomm_dev,
+                                     GError             *error,
                                      gpointer            user_data);
 
 typedef void (*NMBluez5DunNotifyTtyHangupCb)(NMBluez5DunContext *context, gpointer user_data);
 
-gboolean nm_bluez5_dun_connect(const char *                 adapter,
-                               const char *                 remote,
-                               GCancellable *               cancellable,
+gboolean nm_bluez5_dun_connect(const char                  *adapter,
+                               const char                  *remote,
+                               GCancellable                *cancellable,
                                NMBluez5DunConnectCb         callback,
                                gpointer                     callback_user_data,
                                NMBluez5DunNotifyTtyHangupCb notify_tty_hangup_cb,
                                gpointer                     notify_tty_hangup_user_data,
-                               GError **                    error);
+                               GError                     **error);
 
 void nm_bluez5_dun_disconnect(NMBluez5DunContext *context);
 
diff --git a/src/core/devices/bluetooth/nm-device-bt.c b/src/core/devices/bluetooth/nm-device-bt.c
index 3dbfbbe0..39b5c4ec 100644
--- a/src/core/devices/bluetooth/nm-device-bt.c
+++ b/src/core/devices/bluetooth/nm-device-bt.c
@@ -26,7 +26,6 @@
 #include "settings/nm-settings-connection.h"
 #include "nm-utils.h"
 #include "nm-bt-error.h"
-#include "nm-ip4-config.h"
 #include "libnm-platform/nm-platform.h"
 
 #include "devices/wwan/nm-modem-manager.h"
@@ -115,7 +114,7 @@ static NMBluetoothCapabilities
 get_connection_bt_type(NMConnection *connection)
 {
     NMSettingBluetooth *s_bt;
-    const char *        bt_type;
+    const char         *bt_type;
 
     s_bt = nm_connection_get_setting_bluetooth(connection);
 
@@ -133,10 +132,10 @@ get_connection_bt_type(NMConnection *connection)
 }
 
 static gboolean
-get_connection_bt_type_check(NMDeviceBt *             self,
-                             NMConnection *           connection,
+get_connection_bt_type_check(NMDeviceBt              *self,
+                             NMConnection            *connection,
                              NMBluetoothCapabilities *out_bt_type,
-                             GError **                error)
+                             GError                 **error)
 {
     NMBluetoothCapabilities bt_type;
 
@@ -170,8 +169,8 @@ get_generic_capabilities(NMDevice *device)
 static gboolean
 can_auto_connect(NMDevice *device, NMSettingsConnection *sett_conn, char **specific_object)
 {
-    NMDeviceBt *            self = NM_DEVICE_BT(device);
-    NMDeviceBtPrivate *     priv = NM_DEVICE_BT_GET_PRIVATE(self);
+    NMDeviceBt             *self = NM_DEVICE_BT(device);
+    NMDeviceBtPrivate      *priv = NM_DEVICE_BT_GET_PRIVATE(self);
     NMBluetoothCapabilities bt_type;
 
     nm_assert(!specific_object || !*specific_object);
@@ -195,10 +194,10 @@ can_auto_connect(NMDevice *device, NMSettingsConnection *sett_conn, char **speci
 static gboolean
 check_connection_compatible(NMDevice *device, NMConnection *connection, GError **error)
 {
-    NMDeviceBt *        self = NM_DEVICE_BT(device);
-    NMDeviceBtPrivate * priv = NM_DEVICE_BT_GET_PRIVATE(self);
+    NMDeviceBt         *self = NM_DEVICE_BT(device);
+    NMDeviceBtPrivate  *priv = NM_DEVICE_BT_GET_PRIVATE(self);
     NMSettingBluetooth *s_bt;
-    const char *        bdaddr;
+    const char         *bdaddr;
 
     if (!NM_DEVICE_CLASS(nm_device_bt_parent_class)
              ->check_connection_compatible(device, connection, error))
@@ -227,14 +226,14 @@ check_connection_compatible(NMDevice *device, NMConnection *connection, GError *
 }
 
 static gboolean
-check_connection_available(NMDevice *                     device,
-                           NMConnection *                 connection,
+check_connection_available(NMDevice                      *device,
+                           NMConnection                  *connection,
                            NMDeviceCheckConAvailableFlags flags,
-                           const char *                   specific_object,
-                           GError **                      error)
+                           const char                    *specific_object,
+                           GError                       **error)
 {
-    NMDeviceBt *            self = NM_DEVICE_BT(device);
-    NMDeviceBtPrivate *     priv = NM_DEVICE_BT_GET_PRIVATE(self);
+    NMDeviceBt             *self = NM_DEVICE_BT(device);
+    NMDeviceBtPrivate      *priv = NM_DEVICE_BT_GET_PRIVATE(self);
     NMBluetoothCapabilities bt_type;
 
     if (!get_connection_bt_type_check(self, connection, &bt_type, error))
@@ -251,23 +250,23 @@ check_connection_available(NMDevice *                     device,
 }
 
 static gboolean
-complete_connection(NMDevice *           device,
-                    NMConnection *       connection,
-                    const char *         specific_object,
+complete_connection(NMDevice            *device,
+                    NMConnection        *connection,
+                    const char          *specific_object,
                     NMConnection *const *existing_connections,
-                    GError **            error)
+                    GError             **error)
 {
-    NMDeviceBtPrivate * priv = NM_DEVICE_BT_GET_PRIVATE(device);
+    NMDeviceBtPrivate  *priv = NM_DEVICE_BT_GET_PRIVATE(device);
     NMSettingBluetooth *s_bt;
-    const char *        setting_bdaddr;
-    const char *        ctype;
+    const char         *setting_bdaddr;
+    const char         *ctype;
     gboolean            is_dun = FALSE;
     gboolean            is_pan = FALSE;
-    NMSettingGsm *      s_gsm;
-    NMSettingCdma *     s_cdma;
-    NMSettingSerial *   s_serial;
-    NMSettingPpp *      s_ppp;
-    const char *        fallback_prefix = NULL, *preferred = NULL;
+    NMSettingGsm       *s_gsm;
+    NMSettingCdma      *s_cdma;
+    NMSettingSerial    *s_serial;
+    NMSettingPpp       *s_ppp;
+    const char         *fallback_prefix = NULL, *preferred = NULL;
 
     s_gsm    = nm_connection_get_setting_gsm(connection);
     s_cdma   = nm_connection_get_setting_cdma(connection);
@@ -424,44 +423,10 @@ ppp_stats(NMModem *modem, guint i_in_bytes, guint i_out_bytes, gpointer user_dat
 static void
 ppp_failed(NMModem *modem, guint i_reason, gpointer user_data)
 {
-    NMDevice *          device = NM_DEVICE(user_data);
-    NMDeviceBt *        self   = NM_DEVICE_BT(user_data);
+    NMDevice           *device = NM_DEVICE(user_data);
     NMDeviceStateReason reason = i_reason;
 
-    switch (nm_device_get_state(device)) {
-    case NM_DEVICE_STATE_PREPARE:
-    case NM_DEVICE_STATE_CONFIG:
-    case NM_DEVICE_STATE_NEED_AUTH:
-        nm_device_state_changed(device, NM_DEVICE_STATE_FAILED, reason);
-        break;
-    case NM_DEVICE_STATE_IP_CONFIG:
-    case NM_DEVICE_STATE_IP_CHECK:
-    case NM_DEVICE_STATE_SECONDARIES:
-    case NM_DEVICE_STATE_ACTIVATED:
-        if (nm_device_activate_ip4_state_in_conf(device))
-            nm_device_activate_schedule_ip_config_timeout(device, AF_INET);
-        else if (nm_device_activate_ip6_state_in_conf(device))
-            nm_device_activate_schedule_ip_config_timeout(device, AF_INET6);
-        else if (nm_device_activate_ip4_state_done(device)) {
-            nm_device_ip_method_failed(device,
-                                       AF_INET,
-                                       NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
-        } else if (nm_device_activate_ip6_state_done(device)) {
-            nm_device_ip_method_failed(device,
-                                       AF_INET6,
-                                       NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
-        } else {
-            _LOGW(LOGD_MB,
-                  "PPP failure in unexpected state %u",
-                  (guint) nm_device_get_state(device));
-            nm_device_state_changed(device,
-                                    NM_DEVICE_STATE_FAILED,
-                                    NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
-        }
-        break;
-    default:
-        break;
-    }
+    nm_device_state_changed(device, NM_DEVICE_STATE_FAILED, reason);
 }
 
 static void
@@ -481,7 +446,7 @@ modem_auth_requested(NMModem *modem, gpointer user_data)
 static void
 modem_auth_result(NMModem *modem, GError *error, gpointer user_data)
 {
-    NMDevice *         device = NM_DEVICE(user_data);
+    NMDevice          *device = NM_DEVICE(user_data);
     NMDeviceBtPrivate *priv   = NM_DEVICE_BT_GET_PRIVATE(device);
 
     g_return_if_fail(nm_device_get_state(device) == NM_DEVICE_STATE_NEED_AUTH);
@@ -498,8 +463,8 @@ modem_auth_result(NMModem *modem, GError *error, gpointer user_data)
 static void
 modem_prepare_result(NMModem *modem, gboolean success, guint i_reason, gpointer user_data)
 {
-    NMDeviceBt *        self   = user_data;
-    NMDeviceBtPrivate * priv   = NM_DEVICE_BT_GET_PRIVATE(self);
+    NMDeviceBt         *self   = user_data;
+    NMDeviceBtPrivate  *priv   = NM_DEVICE_BT_GET_PRIVATE(self);
     NMDeviceStateReason reason = i_reason;
     NMDeviceState       state;
 
@@ -528,7 +493,7 @@ modem_prepare_result(NMModem *modem, gboolean success, guint i_reason, gpointer
 }
 
 static void
-device_state_changed(NMDevice *          device,
+device_state_changed(NMDevice           *device,
                      NMDeviceState       new_state,
                      NMDeviceState       old_state,
                      NMDeviceStateReason reason)
@@ -547,22 +512,35 @@ device_state_changed(NMDevice *          device,
 }
 
 static void
-modem_ip4_config_result(NMModem *modem, NMIP4Config *config, GError *error, gpointer user_data)
+modem_new_config(NMModem                  *modem,
+                 int                       addr_family,
+                 const NML3ConfigData     *l3cd,
+                 gboolean                  do_auto,
+                 const NMUtilsIPv6IfaceId *iid,
+                 int                       failure_reason_i,
+                 GError                   *error,
+                 gpointer                  user_data)
 {
-    NMDeviceBt *self   = NM_DEVICE_BT(user_data);
-    NMDevice *  device = NM_DEVICE(self);
+    const int   IS_IPv4 = NM_IS_IPv4(addr_family);
+    NMDeviceBt *self    = NM_DEVICE_BT(user_data);
+    NMDevice   *device  = NM_DEVICE(self);
 
-    g_return_if_fail(nm_device_activate_ip4_state_in_conf(device) == TRUE);
+    g_return_if_fail(nm_device_devip_get_state(device, addr_family) == NM_DEVICE_IP_STATE_PENDING);
 
     if (error) {
-        _LOGW(LOGD_MB | LOGD_IP4 | LOGD_BT,
-              "retrieving IP4 configuration failed: %s",
-              error->message);
-        nm_device_ip_method_failed(device, AF_INET, NM_DEVICE_STATE_REASON_IP_CONFIG_UNAVAILABLE);
+        _LOGW(LOGD_MB | LOGD_IP4, "retrieving IP configuration failed: %s", error->message);
+        nm_device_devip_set_failed(device, addr_family, failure_reason_i);
         return;
     }
 
-    nm_device_activate_schedule_ip_config_result(device, AF_INET, NM_IP_CONFIG_CAST(config));
+    if (do_auto) {
+        if (IS_IPv4)
+            nm_device_ip_method_dhcp4_start(device);
+        else
+            nm_device_ip_method_autoconf6_start(device);
+    }
+
+    nm_device_devip_set_state(device, addr_family, NM_DEVICE_IP_STATE_READY, l3cd);
 }
 
 static void
@@ -604,7 +582,7 @@ modem_state_cb(NMModem *modem, int new_state_i, int old_state_i, gpointer user_d
 {
     NMModemState  new_state = new_state_i;
     NMModemState  old_state = old_state_i;
-    NMDevice *    device    = NM_DEVICE(user_data);
+    NMDevice     *device    = NM_DEVICE(user_data);
     NMDeviceState dev_state = nm_device_get_state(device);
 
     if (new_state <= NM_MODEM_STATE_DISABLING && old_state > NM_MODEM_STATE_DISABLING) {
@@ -633,7 +611,7 @@ modem_state_cb(NMModem *modem, int new_state_i, int old_state_i, gpointer user_d
 static void
 modem_removed_cb(NMModem *modem, gpointer user_data)
 {
-    NMDeviceBt *  self = NM_DEVICE_BT(user_data);
+    NMDeviceBt   *self = NM_DEVICE_BT(user_data);
     NMDeviceState state;
 
     state = nm_device_get_state(NM_DEVICE(self));
@@ -651,7 +629,7 @@ static gboolean
 modem_try_claim(NMDeviceBt *self, NMModem *modem)
 {
     NMDeviceBtPrivate *priv             = NM_DEVICE_BT_GET_PRIVATE(self);
-    gs_free char *     rfcomm_base_name = NULL;
+    gs_free char      *rfcomm_base_name = NULL;
     NMDeviceState      state;
 
     if (priv->modem) {
@@ -687,7 +665,7 @@ modem_try_claim(NMDeviceBt *self, NMModem *modem)
     g_signal_connect(modem, NM_MODEM_PPP_STATS, G_CALLBACK(ppp_stats), self);
     g_signal_connect(modem, NM_MODEM_PPP_FAILED, G_CALLBACK(ppp_failed), self);
     g_signal_connect(modem, NM_MODEM_PREPARE_RESULT, G_CALLBACK(modem_prepare_result), self);
-    g_signal_connect(modem, NM_MODEM_IP4_CONFIG_RESULT, G_CALLBACK(modem_ip4_config_result), self);
+    g_signal_connect(modem, NM_MODEM_NEW_CONFIG, G_CALLBACK(modem_new_config), self);
     g_signal_connect(modem, NM_MODEM_AUTH_REQUESTED, G_CALLBACK(modem_auth_requested), self);
     g_signal_connect(modem, NM_MODEM_AUTH_RESULT, G_CALLBACK(modem_auth_result), self);
     g_signal_connect(modem, NM_MODEM_STATE_CHANGED, G_CALLBACK(modem_state_cb), self);
@@ -705,7 +683,7 @@ modem_try_claim(NMDeviceBt *self, NMModem *modem)
 static void
 mm_modem_added_cb(NMModemManager *manager, NMModem *modem, gpointer user_data)
 {
-    NMDeviceBt *       self = user_data;
+    NMDeviceBt        *self = user_data;
     NMDeviceBtPrivate *priv;
 
     if (!modem_try_claim(user_data, modem))
@@ -745,7 +723,7 @@ _nm_device_bt_notify_set_connected(NMDeviceBt *self, gboolean connected)
 static gboolean
 connect_watch_link_idle_cb(gpointer user_data)
 {
-    NMDeviceBt *       self = user_data;
+    NMDeviceBt        *self = user_data;
     NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE(self);
     int                ifindex;
 
@@ -766,15 +744,15 @@ connect_watch_link_idle_cb(gpointer user_data)
 }
 
 static void
-connect_watch_link_cb(NMPlatform *    platform,
+connect_watch_link_cb(NMPlatform     *platform,
                       int             obj_type_i,
                       int             ifindex,
                       NMPlatformLink *info,
                       int             change_type_i,
-                      NMDevice *      self)
+                      NMDevice       *self)
 {
     const NMPlatformSignalChangeType change_type = change_type_i;
-    NMDeviceBtPrivate *              priv;
+    NMDeviceBtPrivate               *priv;
 
     /* bluez doesn't notify us when the connection disconnects.
      * Neither does NMManager (or NMDevice) tell us when the ip-ifindex goes away.
@@ -790,7 +768,7 @@ connect_watch_link_cb(NMPlatform *    platform,
 static gboolean
 connect_wait_modem_timeout(gpointer user_data)
 {
-    NMDeviceBt *       self = NM_DEVICE_BT(user_data);
+    NMDeviceBt        *self = NM_DEVICE_BT(user_data);
     NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE(self);
 
     /* since this timeout is longer than the connect timeout, we must have already
@@ -814,11 +792,11 @@ connect_wait_modem_timeout(gpointer user_data)
 static void
 connect_bz_cb(NMBluezManager *bz_mgr,
               gboolean        is_complete,
-              const char *    device_name,
-              GError *        error,
+              const char     *device_name,
+              GError         *error,
               gpointer        user_data)
 {
-    NMDeviceBt *       self;
+    NMDeviceBt        *self;
     NMDeviceBtPrivate *priv;
     char               sbuf[100];
 
@@ -906,10 +884,10 @@ connect_bz_cb(NMBluezManager *bz_mgr,
 static NMActStageReturn
 act_stage1_prepare(NMDevice *device, NMDeviceStateReason *out_failure_reason)
 {
-    NMDeviceBt *       self     = NM_DEVICE_BT(device);
-    NMDeviceBtPrivate *priv     = NM_DEVICE_BT_GET_PRIVATE(self);
+    NMDeviceBt           *self  = NM_DEVICE_BT(device);
+    NMDeviceBtPrivate    *priv  = NM_DEVICE_BT_GET_PRIVATE(self);
     gs_free_error GError *error = NULL;
-    NMConnection *        connection;
+    NMConnection         *connection;
 
     connection = nm_device_get_applied_connection(device);
     g_return_val_if_fail(connection, NM_ACT_STAGE_RETURN_FAILURE);
@@ -989,38 +967,25 @@ act_stage1_prepare(NMDevice *device, NMDeviceStateReason *out_failure_reason)
 static NMActStageReturn
 act_stage2_config(NMDevice *device, NMDeviceStateReason *out_failure_reason)
 {
-    NMDeviceBt *       self = NM_DEVICE_BT(device);
+    NMDeviceBt        *self = NM_DEVICE_BT(device);
     NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE(self);
 
-    if (priv->connect_bt_type == NM_BT_CAPABILITY_DUN)
-        nm_modem_act_stage2_config(priv->modem);
+    if (priv->connect_bt_type != NM_BT_CAPABILITY_DUN)
+        return NM_ACT_STAGE_RETURN_SUCCESS;
 
-    return NM_ACT_STAGE_RETURN_SUCCESS;
+    return nm_modem_act_stage2_config(priv->modem, device, out_failure_reason);
 }
 
-static NMActStageReturn
-act_stage3_ip_config_start(NMDevice *           device,
-                           int                  addr_family,
-                           gpointer *           out_config,
-                           NMDeviceStateReason *out_failure_reason)
+static void
+act_stage3_ip_config(NMDevice *device, int addr_family)
 {
-    NMDeviceBtPrivate *priv    = NM_DEVICE_BT_GET_PRIVATE(device);
-    gboolean           autoip4 = FALSE;
-    NMActStageReturn   ret;
+    NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE(device);
 
     if (priv->connect_bt_type != NM_BT_CAPABILITY_DUN)
-        goto out_chain_up;
-
-    if (!NM_IS_IPv4(addr_family))
-        return nm_modem_stage3_ip6_config_start(priv->modem, device, out_failure_reason);
-
-    ret = nm_modem_stage3_ip4_config_start(priv->modem, device, &autoip4, out_failure_reason);
-    if (ret != NM_ACT_STAGE_RETURN_SUCCESS || !autoip4)
-        return ret;
+        return;
 
-out_chain_up:
-    return NM_DEVICE_CLASS(nm_device_bt_parent_class)
-        ->act_stage3_ip_config_start(device, addr_family, out_config, out_failure_reason);
+    if (nm_modem_stage3_ip_config_start(priv->modem, addr_family, device))
+        nm_device_devip_set_state(device, addr_family, NM_DEVICE_IP_STATE_PENDING, NULL);
 }
 
 static void
@@ -1070,10 +1035,10 @@ _nm_device_bt_notify_removed(NMDeviceBt *self)
 /*****************************************************************************/
 
 gboolean
-_nm_device_bt_for_same_device(NMDeviceBt *            self,
-                              const char *            dbus_path,
-                              const char *            bdaddr,
-                              const char *            name,
+_nm_device_bt_for_same_device(NMDeviceBt             *self,
+                              const char             *dbus_path,
+                              const char             *bdaddr,
+                              const char             *name,
                               NMBluetoothCapabilities capabilities)
 {
     NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE(self);
@@ -1102,7 +1067,7 @@ _nm_device_bt_notify_set_name(NMDeviceBt *self, const char *name)
 static gboolean
 is_available(NMDevice *dev, NMDeviceCheckDevAvailableFlags flags)
 {
-    NMDeviceBt *       self = NM_DEVICE_BT(dev);
+    NMDeviceBt        *self = NM_DEVICE_BT(dev);
     NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE(self);
 
     /* PAN doesn't need ModemManager, so devices that support it are always available */
@@ -1206,7 +1171,7 @@ nm_device_bt_init(NMDeviceBt *self)
 static void
 constructed(GObject *object)
 {
-    NMDeviceBt *       self = NM_DEVICE_BT(object);
+    NMDeviceBt        *self = NM_DEVICE_BT(object);
     NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE(self);
 
     G_OBJECT_CLASS(nm_device_bt_parent_class)->constructed(object);
@@ -1229,10 +1194,10 @@ constructed(GObject *object)
 }
 
 NMDeviceBt *
-nm_device_bt_new(NMBluezManager *        bz_mgr,
-                 const char *            dbus_path,
-                 const char *            bdaddr,
-                 const char *            name,
+nm_device_bt_new(NMBluezManager         *bz_mgr,
+                 const char             *dbus_path,
+                 const char             *bdaddr,
+                 const char             *name,
                  NMBluetoothCapabilities capabilities)
 {
     g_return_val_if_fail(NM_IS_BLUEZ_MANAGER(bz_mgr), NULL);
@@ -1270,7 +1235,7 @@ nm_device_bt_new(NMBluezManager *        bz_mgr,
 static void
 dispose(GObject *object)
 {
-    NMDeviceBt *       self = NM_DEVICE_BT(object);
+    NMDeviceBt        *self = NM_DEVICE_BT(object);
     NMDeviceBtPrivate *priv = NM_DEVICE_BT_GET_PRIVATE(self);
 
     nm_clear_g_signal_handler(nm_device_get_platform(NM_DEVICE(self)),
@@ -1325,9 +1290,9 @@ static const NMDBusInterfaceInfoExtended interface_info_device_bluetooth = {
 static void
 nm_device_bt_class_init(NMDeviceBtClass *klass)
 {
-    GObjectClass *     object_class      = G_OBJECT_CLASS(klass);
+    GObjectClass      *object_class      = G_OBJECT_CLASS(klass);
     NMDBusObjectClass *dbus_object_class = NM_DBUS_OBJECT_CLASS(klass);
-    NMDeviceClass *    device_class      = NM_DEVICE_CLASS(klass);
+    NMDeviceClass     *device_class      = NM_DEVICE_CLASS(klass);
 
     object_class->constructed  = constructed;
     object_class->get_property = get_property;
@@ -1344,7 +1309,7 @@ nm_device_bt_class_init(NMDeviceBtClass *klass)
     device_class->deactivate                  = deactivate;
     device_class->act_stage1_prepare          = act_stage1_prepare;
     device_class->act_stage2_config           = act_stage2_config;
-    device_class->act_stage3_ip_config_start  = act_stage3_ip_config_start;
+    device_class->act_stage3_ip_config        = act_stage3_ip_config;
     device_class->check_connection_compatible = check_connection_compatible;
     device_class->check_connection_available  = check_connection_available;
     device_class->complete_connection         = complete_connection;
diff --git a/src/core/devices/bluetooth/nm-device-bt.h b/src/core/devices/bluetooth/nm-device-bt.h
index c2d3bc18..59457fba 100644
--- a/src/core/devices/bluetooth/nm-device-bt.h
+++ b/src/core/devices/bluetooth/nm-device-bt.h
@@ -33,15 +33,15 @@ GType nm_device_bt_get_type(void);
 struct _NMBluezManager;
 
 NMDeviceBt *nm_device_bt_new(struct _NMBluezManager *bz_mgr,
-                             const char *            dbus_path,
-                             const char *            bdaddr,
-                             const char *            name,
+                             const char             *dbus_path,
+                             const char             *bdaddr,
+                             const char             *name,
                              NMBluetoothCapabilities capabilities);
 
-gboolean _nm_device_bt_for_same_device(NMDeviceBt *            device,
-                                       const char *            dbus_path,
-                                       const char *            bdaddr,
-                                       const char *            name,
+gboolean _nm_device_bt_for_same_device(NMDeviceBt             *device,
+                                       const char             *dbus_path,
+                                       const char             *bdaddr,
+                                       const char             *name,
                                        NMBluetoothCapabilities capabilities);
 
 NMBluetoothCapabilities nm_device_bt_get_capabilities(NMDeviceBt *device);
diff --git a/src/core/devices/bluetooth/tests/nm-bt-test.c b/src/core/devices/bluetooth/tests/nm-bt-test.c
index 548e7249..5aab48a5 100644
--- a/src/core/devices/bluetooth/tests/nm-bt-test.c
+++ b/src/core/devices/bluetooth/tests/nm-bt-test.c
@@ -23,8 +23,8 @@
 struct {
     int                argc;
     const char *const *argv;
-    const char *       argv_cmd;
-    GMainLoop *        loop;
+    const char        *argv_cmd;
+    GMainLoop         *loop;
 } gl;
 
 typedef struct _MainCmdInfo {
@@ -38,7 +38,7 @@ typedef struct _MainCmdInfo {
 
 typedef struct {
     NMBluez5DunContext *dun_context;
-    GCancellable *      cancellable;
+    GCancellable       *cancellable;
     guint               timeout_id;
     guint               sig_term_id;
     guint               sig_int_id;
@@ -46,8 +46,8 @@ typedef struct {
 
 static void
 _dun_connect_cb(NMBluez5DunContext *context,
-                const char *        rfcomm_dev,
-                GError *            error,
+                const char         *rfcomm_dev,
+                GError             *error,
                 gpointer            user_data)
 {
     DunConnectData *dun_connect_data = user_data;
@@ -118,10 +118,10 @@ do_dun_connect(const MainCmdInfo *main_cmd_info)
 {
 #if WITH_BLUEZ5_DUN
     gs_unref_object GCancellable *cancellable = NULL;
-    gs_free_error GError *error               = NULL;
-    const char *          adapter;
-    const char *          remote;
-    DunConnectData        dun_connect_data = {};
+    gs_free_error GError         *error       = NULL;
+    const char                   *adapter;
+    const char                   *remote;
+    DunConnectData                dun_connect_data = {};
 
     if (gl.argc < 4) {
         _LOGE("missing arguments \"adapter\" and \"remote\"");