ConnectDevice: Connect bluetooth device without scanning

bluez_adapter_connect.c

/*
 * bluez_adapter_connect.c - Connect with device without StartDiscovery
 * 	- This example registers an agen with NoInputOutput capability for the purpose of
 *	  auto pairing
 * 	- Use ConnectDevice method to connect with device using provided MAC address
 *	- Usual signal subscription to get the details of the connected device
 *	- Introduced new signal handler to exit the program gracefully
 *
 *	Note: As "ConnectDevice" is new API and in experimental state (but mostly stable)
 *	one need to use "-E" option when starting "bluetoothd". Systems running systemd can
 *	edit /lib/systemd/system/bluetooth.service in ExecStart option
 *
 *	When this API is useful?
 *	- When you already have the MAC address of end bluetooth Device to connect with, then
 *	  you don't need to scan for the device (with or without filter) and connect it.
 *	- StartDiscovery + Pair + Connect => ConnectDevice
 *
 *	How you will have MAC address before scanning?
 *	- When you have other communication (wired or wireless) medium to exchange the MAC address
 *	- For example, NFC OOB can be used to exchange the MAC address
 *	- Testing Bluetooth with same device (MAC address known)
 *
 *	- Here Agent capability is registered as "NoInputOutput" for experimental purpose only, in
 *	  real world scenario, Pair + Connect involves real Agents.
 *	- Also note, bluez_agent_call_method and bluez_adapter_call_method are two different methods doing
 *	  the same work with difference in interface name and object path. This exist just to make the
 * 	  understanding more clear.
 *
 * gcc `pkg-config --cflags glib-2.0 gio-2.0` -Wall -Wextra -o ./bin/bluez_adapter_connect ./bluez_adapter_connect.c `pkg-config --libs glib-2.0 gio-2.0`
 */
#include <glib.h>
#include <gio/gio.h>
#include <signal.h>

GMainLoop *loop;
GDBusConnection *con;
static void bluez_property_value(const gchar *key, GVariant *value)
{
	const gchar *type = g_variant_get_type_string(value);

	g_print("\t%s : ", key);
	switch(*type) {
		case 'o':
		case 's':
			g_print("%s\n", g_variant_get_string(value, NULL));
			break;
		case 'b':
			g_print("%d\n", g_variant_get_boolean(value));
			break;
		case 'u':
			g_print("%d\n", g_variant_get_uint32(value));
			break;
		case 'a':
		/* TODO Handling only 'as', but not array of dicts */
			if(g_strcmp0(type, "as"))
				break;
			g_print("\n");
			const gchar *uuid;
			GVariantIter i;
			g_variant_iter_init(&i, value);
			while(g_variant_iter_next(&i, "s", &uuid))
				g_print("\t\t%s\n", uuid);
			break;
		default:
			g_print("Other\n");
			break;
	}
}

typedef void (*method_cb_t)(GObject *, GAsyncResult *, gpointer);
static int bluez_adapter_call_method(const char *method, GVariant *param, method_cb_t method_cb)
{
	g_dbus_connection_call(con,
			     "org.bluez",
			/* TODO Find the adapter path runtime */
			     "/org/bluez/hci0",
			     "org.bluez.Adapter1",
			     method,
			     param,
			     NULL,
			     G_DBUS_CALL_FLAGS_NONE,
			     -1,
			     NULL,
			     method_cb,
			     (void *)method);
	return 0;
}

static void bluez_result_async_cb(GObject *con,
				  GAsyncResult *res,
				  gpointer data)
{
	const gchar *key = (gchar *)data;
	GVariant *result = NULL;
	GError *error = NULL;

	result = g_dbus_connection_call_finish((GDBusConnection *)con, res, &error);
	if(error != NULL) {
		g_print("Unable to get result: %s\n", error->message);
		return;
	}

	if(result) {
		result = g_variant_get_child_value(result, 0);
		bluez_property_value(key, result);
	}
	g_variant_unref(result);
}

static void bluez_device_appeared(GDBusConnection *sig,
				const gchar *sender_name,
				const gchar *object_path,
				const gchar *interface,
				const gchar *signal_name,
				GVariant *parameters,
				gpointer user_data)
{
	(void)sig;
	(void)sender_name;
	(void)object_path;
	(void)interface;
	(void)signal_name;
	(void)user_data;

	GVariantIter *interfaces;
	const char *object;
	const gchar *interface_name;
	GVariant *properties;

	g_variant_get(parameters, "(&oa{sa{sv}})", &object, &interfaces);
	while(g_variant_iter_next(interfaces, "{&s@a{sv}}", &interface_name, &properties)) {
		if(g_strstr_len(g_ascii_strdown(interface_name, -1), -1, "device")) {
			g_print("[ %s ]\n", object);
			const gchar *property_name;
			GVariantIter i;
			GVariant *prop_val;
			g_variant_iter_init(&i, properties);
			while(g_variant_iter_next(&i, "{&sv}", &property_name, &prop_val))
				bluez_property_value(property_name, prop_val);
			g_variant_unref(prop_val);
		}
		g_variant_unref(properties);
	}
	return;
}

#define BT_ADDRESS_STRING_SIZE 18
static void bluez_device_disappeared(GDBusConnection *sig,
				const gchar *sender_name,
				const gchar *object_path,
				const gchar *interface,
				const gchar *signal_name,
				GVariant *parameters,
				gpointer user_data)
{
	(void)sig;
	(void)sender_name;
	(void)object_path;
	(void)interface;
	(void)signal_name;

	GVariantIter *interfaces;
	const char *object;
	const gchar *interface_name;
	char address[BT_ADDRESS_STRING_SIZE] = {'\0'};

	g_variant_get(parameters, "(&oas)", &object, &interfaces);
	while(g_variant_iter_next(interfaces, "s", &interface_name)) {
		if(g_strstr_len(g_ascii_strdown(interface_name, -1), -1, "device")) {
			int i;
			char *tmp = g_strstr_len(object, -1, "dev_") + 4;

			for(i = 0; *tmp != '\0'; i++, tmp++) {
				if(*tmp == '_') {
					address[i] = ':';
					continue;
				}
				address[i] = *tmp;
			}
			g_print("\nDevice %s removed\n", address);
			g_main_loop_quit((GMainLoop *)user_data);
		}
	}
	return;
}

static void bluez_signal_adapter_changed(GDBusConnection *conn,
					const gchar *sender,
					const gchar *path,
					const gchar *interface,
					const gchar *signal,
					GVariant *params,
					void *userdata)
{
	(void)conn;
	(void)sender;
	(void)path;
	(void)interface;
	(void)userdata;

	GVariantIter *properties = NULL;
	GVariantIter *unknown = NULL;
	const char *iface;
	const char *key;
	GVariant *value = NULL;
	const gchar *signature = g_variant_get_type_string(params);

	if(strcmp(signature, "(sa{sv}as)") != 0) {
		g_print("Invalid signature for %s: %s != %s", signal, signature, "(sa{sv}as)");
		goto done;
	}

	g_variant_get(params, "(&sa{sv}as)", &iface, &properties, &unknown);
	while(g_variant_iter_next(properties, "{&sv}", &key, &value)) {
		if(!g_strcmp0(key, "Powered")) {
			if(!g_variant_is_of_type(value, G_VARIANT_TYPE_BOOLEAN)) {
				g_print("Invalid argument type for %s: %s != %s", key,
						g_variant_get_type_string(value), "b");
				goto done;
			}
			g_print("Adapter is Powered \"%s\"\n", g_variant_get_boolean(value) ? "on" : "off");
		}
		if(!g_strcmp0(key, "Discovering")) {
			if(!g_variant_is_of_type(value, G_VARIANT_TYPE_BOOLEAN)) {
				g_print("Invalid argument type for %s: %s != %s", key,
						g_variant_get_type_string(value), "b");
				goto done;
			}
			g_print("Adapter scan \"%s\"\n", g_variant_get_boolean(value) ? "on" : "off");
		}
	}
done:
	if(properties != NULL)
		g_variant_iter_free(properties);
	if(value != NULL)
		g_variant_unref(value);
}

static int bluez_adapter_set_property(const char *prop, GVariant *value)
{
	GVariant *result;
	GError *error = NULL;

	result = g_dbus_connection_call_sync(con,
					     "org.bluez",
					     "/org/bluez/hci0",
					     "org.freedesktop.DBus.Properties",
					     "Set",
					     g_variant_new("(ssv)", "org.bluez.Adapter1", prop, value),
					     NULL,
					     G_DBUS_CALL_FLAGS_NONE,
					     -1,
					     NULL,
					     &error);
	if(error != NULL)
		return 1;

	g_variant_unref(result);
	return 0;
}

static int bluez_adapter_connect_device(char **argv)
{
	int rc;
	GVariantBuilder *b = g_variant_builder_new(G_VARIANT_TYPE_VARDICT);
	g_variant_builder_add(b, "{sv}", "Address", g_variant_new_string(argv[1]));
	GVariant *device_dict = g_variant_builder_end(b);
	g_variant_builder_unref(b);

	rc = bluez_adapter_call_method("ConnectDevice",
					g_variant_new_tuple(&device_dict, 1),
					bluez_result_async_cb);
	if(rc) {
		g_print("Not able to call ConnectDevice\n");
		return 1;
	}

	return 0;
}

#define AGENT_PATH "/org/bluez/AutoPinAgent"
static int bluez_agent_call_method(const gchar *method, GVariant *param)
{
        GVariant *result;
        GError *error = NULL;

        result = g_dbus_connection_call_sync(con,
                                             "org.bluez",
                                             "/org/bluez",
                                             "org.bluez.AgentManager1",
                                             method,
                                             param,
                                             NULL,
                                             G_DBUS_CALL_FLAGS_NONE,
                                             -1,
                                             NULL,
                                             &error);
        if(error != NULL) {
		g_print("Register %s: %s\n", AGENT_PATH, error->message);
                return 1;
	}

        g_variant_unref(result);
        return 0;
}

static int bluez_register_autopair_agent(void)
{
	int rc;

	rc = bluez_agent_call_method("RegisterAgent", g_variant_new("(os)", AGENT_PATH, "NoInputNoOutput"));
	if(rc)
		return 1;

	rc = bluez_agent_call_method("RequestDefaultAgent", g_variant_new("(o)", AGENT_PATH));
	if(rc) {
		bluez_agent_call_method("UnregisterAgent", g_variant_new("(o)", AGENT_PATH));
		return 1;
	}

	return 0;
}

static void cleanup_handler(int signo)
{
	if (signo == SIGINT) {
		g_print("received SIGINT\n");
		g_main_loop_quit(loop);
	}
}

int main(int argc, char **argv)
{
	int rc;
	guint prop_changed;
	guint iface_added;
	guint iface_removed;

	if(signal(SIGINT, cleanup_handler) == SIG_ERR)
		g_print("can't catch SIGINT\n");

	con = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
	if(con == NULL) {
		g_print("Not able to get connection to system bus\n");
		return 1;
	}

	loop = g_main_loop_new(NULL, FALSE);

	prop_changed = g_dbus_connection_signal_subscribe(con,
						"org.bluez",
						"org.freedesktop.DBus.Properties",
						"PropertiesChanged",
						NULL,
						"org.bluez.Adapter1",
						G_DBUS_SIGNAL_FLAGS_NONE,
						bluez_signal_adapter_changed,
						NULL,
						NULL);

	iface_added = g_dbus_connection_signal_subscribe(con,
							"org.bluez",
							"org.freedesktop.DBus.ObjectManager",
							"InterfacesAdded",
							NULL,
							NULL,
							G_DBUS_SIGNAL_FLAGS_NONE,
							bluez_device_appeared,
							loop,
							NULL);

	iface_removed = g_dbus_connection_signal_subscribe(con,
							"org.bluez",
							"org.freedesktop.DBus.ObjectManager",
							"InterfacesRemoved",
							NULL,
							NULL,
							G_DBUS_SIGNAL_FLAGS_NONE,
							bluez_device_disappeared,
							loop,
							NULL);

	rc = bluez_adapter_set_property("Powered", g_variant_new("b", TRUE));
	if(rc) {
		g_print("Not able to enable the adapter\n");
		goto fail;
	}

	rc = bluez_register_autopair_agent();
	if(rc) {
		g_print("Not able to register default autopair agent\n");
		goto fail;
	}

	if(argc == 2) {
		rc = bluez_adapter_connect_device(argv);
		if(rc)
			goto fail;
	}

	g_main_loop_run(loop);

	rc = bluez_adapter_set_property("Powered", g_variant_new("b", FALSE));
	if(rc)
		g_print("Not able to disable the adapter\n");
fail:
	g_dbus_connection_signal_unsubscribe(con, prop_changed);
	g_dbus_connection_signal_unsubscribe(con, iface_added);
	g_dbus_connection_signal_unsubscribe(con, iface_removed);
	g_object_unref(con);
	return 0;
}

Hello. Thank you for making this example to help people learn. However, I haven't been able to get this to work. I am running the latest bluez (5.64) with bluetoothd launched with the "-E" CLI parameter for experimental interface enablement, on a Raspberry Pi 4b

ps aux | grep bluetoothd
root       753  0.0  0.3   7200  3536 ?        Ss   12:22   0:00 /usr/local/libexec/bluetooth/bluetoothd -E
root     17102  0.0  0.0   7348   528 pts/1    S+   13:52   0:00 grep bluetoothd

When I run the tool to connect to a bluetooth classic wireless headphones device in discoverable mode, I get the following:

./bluez_adapter_connect 1C:36:BB:32:F5:13
Adapter is Powered "on"
Unable to get result: GDBus.Error:org.bluez.Error.AlreadyExists: Already Exists

If it is instead not in pairing mode I get

./bluez_adapter_connect 1C:36:BB:32:F5:13
Unable to get result: GDBus.Error:org.bluez.Error.AlreadyExists: Already Exists

I am able to pair and connect to this same device from bluetoothctl fine when it is in pairing mode:

# bluetoothctl
Agent registered
AdvertisementMonitor path registered
[bluetooth]# connect 1C:36:BB:32:F5:13
Attempting to connect to 1C:36:BB:32:F5:13
[CHG] Device 1C:36:BB:32:F5:13 Connected: yes
Connection successful
[CHG] Device 1C:36:BB:32:F5:13 ServicesResolved: yes

And when I use this code to try and connect to a "virtual peripheral" created with the LightBlue app on my iPad, I see one of the two following ouputs.

This is what I get if I don't have bluetoothctl in "scan on" mode:

./bluez_adapter_connect 41:3E:7B:64:29:A8
Adapter is Powered "on"
Unable to get result: GDBus.Error:org.bluez.Failed: 

This is what I get if I do have bluetoothctl in "scan on" mode:

./bluez_adapter_connect 5D:39:63:B1:1D:B1
Unable to get result: GDBus.Error:org.bluez.Error.AlreadyExists: Already Exists

So three things:

1. According to the ConnectDevice API, it needs an "AddressType" parameter and "If this parameter is not present BR/EDR device is created." So that seems to mean that this code could never work if the BDADDR is a random type address, correct?
   This seems to be confirmed based on the fact that if I add a line

g_variant_builder_add(b, "{sv}", "AddressType", g_variant_new_string("random"));

right below the "Address" line, it seems to connect to the virtual device now, based on the below output:

./bluez_adapter_connect 5D:39:63:B1:1D:B1
Adapter is Powered "on"
[ /org/bluez/hci0/dev_5D_39_63_B1_1D_B1 ]
        Address : 5D:39:63:B1:1D:B1
        AddressType : random
        Alias : 5D-39-63-B1-1D-B1
        Paired : 0
        Trusted : 0
        Blocked : 0
        LegacyPairing : 0
        Connected : 1
        UUIDs : 
        Adapter : /org/bluez/hci0
        ServicesResolved : 0
        ConnectDevice : /org/bluez/hci0/dev_5D_39_63_B1_1D_B1

2. However, that still doesn't explain why I can't connect to the BT classic device in either pairing or non-pairing mode. Any ideas on that?

3. Any idea why there is the "Already Exists" error if I don't add the "random" AddressType?

p.s. if you'd like some code to improve that TODO in bluez_property_value() I used the following improvement for case a:

                case 'a':
                        if(strcmp("UUIDs", key) == 0){
                                g_print("\n");
                                const gchar *uuid;
                                GVariantIter i;
                                g_variant_iter_init(&i, value);
                                while(g_variant_iter_next(&i, "s", &uuid))
                                        g_print("\t\t%s\n", uuid);
                        }
                        else if(strcmp("ManufacturerData", key) == 0){
                                g_print("\n");
                                GVariantIter i;
                                short manufacturer_id;
                                GVariant *byte_array;
                                g_variant_iter_init(&i, value);
                                while(g_variant_iter_next(&i, "{qv}", &manufacturer_id, &byte_array)){
                                        g_print("\t\tManufacturerID: 0x%04x (%s)\n", manufacturer_id, bt_compidtostr(manufacturer_id));
                                        g_print("\t\tHex byte array:");
                                        char byte;
                                        GVariantIter ii;
                                        g_variant_iter_init(&ii, byte_array);
                                        while(g_variant_iter_next(&ii, "y", &byte)){
                                                g_print(" %02x", byte);
                                        }
                                        g_print("\n");
                                }
                        }
                        else if(strcmp("ServiceData", key) == 0){
                                g_print("\n");
                                GVariantIter i;
                                const gchar *uuid;;
                                GVariant *byte_array;
                                g_variant_iter_init(&i, value);
                                while(g_variant_iter_next(&i, "{sv}", &uuid, &byte_array)){
                                        g_print("\t\tUUID: %s\n", uuid);  
                                        g_print("\t\tHex byte array:");
                                        char byte;
                                        GVariantIter ii;
                                        g_variant_iter_init(&ii, byte_array);
                                        while(g_variant_iter_next(&ii, "y", &byte)){
                                                g_print(" %02x", byte);
                                        }
                                        g_print("\n");
                                }
                        }
                        else{   
                                g_print("value type '%s'\n", g_variant_get_type_string(value));
                                g_print("something unknown...\n");
                        }
                        break;

(I don't really understand how to just dynamically parse anything that comes in, because e.g. if I run g_variant_get_type_string(value) I get things like "a{qv}" or "a{sv}", but I need things like "{qv}" or "{sv}" and it seems weird and gross to just like chop off the "a" at the front of the string.)

@9293746 Unfortunately I haven't followed the bluez project changes for quit sometime. I would recommend to read the API level changes in doc/adapter.txt and doc/device.txt in bluez