void bluez_unregister_watcher(GDBusConnection* conn, const gchar* service_path)
{
GError* error = NULL;
GDBusMessage* call_message = g_dbus_message_new_method_call("org.bluez",
service_path,
"org.bluez.Characteristic",
"UnregisterCharacteristicsWatcher");
if(call_message == NULL)
{
printf("g_dbus_message_new_method_call failed\n");
return;
}
gchar path[255];
g_snprintf(path, 255, "/test/bluez/%d", getpid());
GVariant* variant_addr = g_variant_new_object_path(path);
GVariant* variant_body = g_variant_new_tuple(&variant_addr, 1);
g_dbus_message_set_body(call_message, variant_body);
GDBusMessage* reply_message = g_dbus_connection_send_message_with_reply_sync(conn,
call_message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
-1,
NULL,
NULL,
&error);
if(reply_message == NULL)
{
printf("g_dbus_connection_send_message_with_reply_sync failed\n");
return;
}
if(g_dbus_message_get_message_type(reply_message) == G_DBUS_MESSAGE_TYPE_ERROR)
{
printf("Error occured\n");
g_dbus_message_to_gerror(reply_message, &error);
g_printerr("Error invoking g_dbus_connection_send_message_with_reply_sync: %s\n", error->message);
g_error_free(error);
return;
}
// cleanup
g_object_unref(call_message);
g_object_unref(reply_message);
}
// returns the object path to a given device or NULL if failed
// object path has to be freed with g_free()
gchar* bluez_find_device(GDBusConnection* conn, const gchar* adapter_path, const char* bt_addr)
{
GError* error = NULL;
GDBusMessage* call_message = g_dbus_message_new_method_call("org.bluez",
adapter_path,
"org.bluez.Adapter",
"FindDevice");
if(call_message == NULL)
{
return NULL;
}
GVariant* variant_addr = g_variant_new_string(bt_addr);
GVariant* variant_body = g_variant_new_tuple(&variant_addr, 1);
g_dbus_message_set_body(call_message, variant_body);
GDBusMessage* reply_message = g_dbus_connection_send_message_with_reply_sync(conn,
call_message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
-1,
NULL,
NULL,
&error);
if(reply_message == NULL)
{
return NULL;
}
if(g_dbus_message_get_message_type(reply_message) == G_DBUS_MESSAGE_TYPE_ERROR)
{
return NULL;
}
GVariant* variant = g_dbus_message_get_body(reply_message);
// get first child, as this is the object path of the default interface of bluez
GVariant* var_child = g_variant_get_child_value(variant, 0);
const gchar* tmp_path = g_variant_get_string(var_child, NULL);
// copy content of tmp_path to obj_path, as tmp_path gets freed after unref of the variant
gchar* obj_path = g_strdup(tmp_path);
// cleanup
g_variant_unref(var_child);
g_object_unref(call_message);
g_object_unref(reply_message);
return obj_path;
}
GVariant* bluez_characteristic_get_value(GDBusConnection* conn, const gchar* char_path)
{
GError* error = NULL;
GDBusMessage* call_message = g_dbus_message_new_method_call("org.bluez",
char_path,
"org.bluez.Characteristic",
"GetProperties");
if(call_message == NULL)
{
g_printf("g_dbus_message_new_method_call failed\n");
return NULL;
}
GDBusMessage* reply_message = g_dbus_connection_send_message_with_reply_sync(conn,
call_message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
-1,
NULL,
NULL,
&error);
if(reply_message == NULL)
{
g_printf("g_dbus_connection_send_message_with_reply_sync failed\n");
return NULL;
}
if(g_dbus_message_get_message_type(reply_message) == G_DBUS_MESSAGE_TYPE_ERROR)
{
g_printf("Error occured\n");
g_dbus_message_to_gerror(reply_message, &error);
g_printerr("Error invoking g_dbus_connection_send_message_with_reply_sync: %s\n", error->message);
g_error_free(error);
return NULL;
}
GVariant* var_body = g_dbus_message_get_body(reply_message);
g_variant_ref(var_body);
// cleanup
g_object_unref(call_message);
g_object_unref(reply_message);
return var_body;
}
static void
message_logged_cb (
BustlePcapMonitor *pcap,
GDBusMessage *message,
gboolean is_incoming,
glong sec,
glong usec,
guint8 *data,
guint len,
gpointer user_data)
{
g_print ("(%s) %s -> %s: %u %s\n",
is_incoming ? "incoming" : "outgoing",
g_dbus_message_get_sender (message),
g_dbus_message_get_destination (message),
g_dbus_message_get_message_type (message),
g_dbus_message_get_member (message));
}
/* see gdbus-example-server.c for the server implementation */
static gint
get_server_stdout (GDBusConnection *connection,
const gchar *name_owner,
GError **error)
{
GDBusMessage *method_call_message;
GDBusMessage *method_reply_message;
GUnixFDList *fd_list;
gint fd;
fd = -1;
method_call_message = NULL;
method_reply_message = NULL;
method_call_message = g_dbus_message_new_method_call (name_owner,
"/org/gtk/GDBus/TestObject",
"org.gtk.GDBus.TestInterface",
"GimmeStdout");
method_reply_message = g_dbus_connection_send_message_with_reply_sync (connection,
method_call_message,
-1,
NULL, /* out_serial */
NULL, /* cancellable */
error);
if (method_reply_message == NULL)
goto out;
if (g_dbus_message_get_message_type (method_reply_message) == G_DBUS_MESSAGE_TYPE_ERROR)
{
g_dbus_message_to_gerror (method_reply_message, error);
goto out;
}
fd_list = g_dbus_message_get_unix_fd_list (method_reply_message);
fd = g_unix_fd_list_get (fd_list, 0, error);
out:
g_object_unref (method_call_message);
g_object_unref (method_reply_message);
return fd;
}
static GDBusMessage *
on_connection_filter (GDBusConnection *connection,
GDBusMessage *message,
gboolean incoming,
gpointer user_data)
{
GDBusMessageType type;
const gchar *sender;
if (!incoming)
return message;
type = g_dbus_message_get_message_type (message);
if (type == G_DBUS_MESSAGE_TYPE_METHOD_CALL)
{
sender = g_dbus_message_get_sender (message);
g_return_val_if_fail (sender != NULL, NULL);
invocation_client_create (connection, sender);
}
return message;
}
static gint64
arv_rtkit_get_int_property (GDBusConnection *connection, const char* propname, GError **error) {
GDBusMessage *message;
GDBusMessage *reply;
GError *local_error = NULL;
GVariant *body;
GVariant *parameter;
GVariant *variant;
const GVariantType *variant_type;
gint64 value;
message = g_dbus_message_new_method_call (RTKIT_SERVICE_NAME,
RTKIT_OBJECT_PATH,
"org.freedesktop.DBus.Properties",
"Get");
g_dbus_message_set_body (message, g_variant_new ("(ss)", "org.freedesktop.RealtimeKit1", propname));
reply = g_dbus_connection_send_message_with_reply_sync (connection, message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE, 1000, NULL, NULL,
&local_error);
g_object_unref (message);
if (local_error != NULL) {
g_propagate_error (error, local_error);
return 0;
}
if (g_dbus_message_get_message_type (reply) != G_DBUS_MESSAGE_TYPE_METHOD_RETURN) {
local_error = g_error_new (ARV_RTKIT_ERROR, ARV_RTKIT_ERROR_PERMISSION_DENIED,
"%s", g_dbus_message_get_error_name (reply));
g_propagate_error (error, local_error);
g_object_unref (reply);
return 0;
}
if (!g_variant_type_equal ("v", g_dbus_message_get_signature (reply))) {
local_error = g_error_new (ARV_RTKIT_ERROR, ARV_RTKIT_ERROR_WRONG_REPLY,
"Invalid reply signature");
g_propagate_error (error, local_error);
g_object_unref (reply);
return 0;
}
body = g_dbus_message_get_body (reply);
parameter = g_variant_get_child_value (body, 0);
variant = g_variant_get_variant (parameter);
variant_type = g_variant_get_type (variant);
if (g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT32))
value = g_variant_get_int32 (variant);
else if (g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT64))
value = g_variant_get_int64 (variant);
else
value = 0;
g_variant_unref (parameter);
g_variant_unref (variant);
g_object_unref (reply);
return value;
}
static GDBusMessage *
notification_filter_func (GDBusConnection *connection,
GDBusMessage *message,
gboolean *incoming,
gpointer user_data)
{
GDBusMessage *ret = NULL;
gboolean transient = FALSE;
gchar *sender_str = NULL;
CsNotificationWatcher *watcher = CS_NOTIFICATION_WATCHER (user_data);
if (incoming &&
g_dbus_message_get_message_type (message) == G_DBUS_MESSAGE_TYPE_METHOD_CALL &&
g_strcmp0 (g_dbus_message_get_interface (message), NOTIFICATIONS_INTERFACE) == 0 &&
g_strcmp0 (g_dbus_message_get_member (message), NOTIFY_METHOD) == 0)
{
GVariant *body = g_dbus_message_get_body (message);
if (body != NULL &&
g_variant_is_of_type (body, G_VARIANT_TYPE_TUPLE) &&
g_variant_n_children (body) >= 7)
{
GVariant *hints, *sender;
if (debug_mode)
{
GVariant *dbg_var = NULL;
const gchar *dbg_str;
g_printerr ("Notification received...\n");
dbg_var = g_variant_get_child_value (body, 0);
if (dbg_var != NULL && g_variant_is_of_type (dbg_var, G_VARIANT_TYPE_STRING))
{
dbg_str = g_variant_get_string (dbg_var, NULL);
if (dbg_str != NULL)
{
g_printerr ("Sender: %s\n", dbg_str);
}
}
g_clear_pointer (&dbg_var, g_variant_unref);
dbg_var = g_variant_get_child_value (body, 3);
if (dbg_var != NULL && g_variant_is_of_type (dbg_var, G_VARIANT_TYPE_STRING))
{
dbg_str = g_variant_get_string (dbg_var, NULL);
if (dbg_str != NULL)
{
g_printerr ("Summary: %s\n", dbg_str);
}
}
g_clear_pointer (&dbg_var, g_variant_unref);
dbg_var = g_variant_get_child_value (body, 4);
if (dbg_var != NULL && g_variant_is_of_type (dbg_var, G_VARIANT_TYPE_STRING))
{
dbg_str = g_variant_get_string (dbg_var, NULL);
if (dbg_str != NULL)
{
g_printerr ("Body: %s\n", dbg_str);
}
}
g_clear_pointer (&dbg_var, g_variant_unref);
}
hints = g_variant_get_child_value (body, 6);
if (hints != NULL && g_variant_is_of_type (hints, G_VARIANT_TYPE_DICTIONARY))
{
GVariant *transient_hint;
transient_hint = g_variant_lookup_value (hints, "transient", NULL);
if (transient_hint)
{
transient = g_variant_get_boolean (transient_hint);
}
g_clear_pointer (&transient_hint, g_variant_unref);
}
g_clear_pointer (&hints, g_variant_unref);
sender = g_variant_get_child_value (body, 0);
if (sender)
{
sender_str = g_variant_dup_string (sender, NULL);
}
g_clear_pointer (&sender, g_variant_unref);
}
}
else
{
ret = message;
}
if (ret == NULL && !transient)
{
NotificationIdleData *data = g_slice_new0 (NotificationIdleData);
data->watcher = watcher;
data->sender = sender_str;
g_idle_add (idle_notify_received, data);
}
return ret;
}
gboolean
eas_gdbus_call_finish (struct eas_gdbus_client *client, GAsyncResult *result,
guint cancel_serial, const gchar *out_params,
va_list *ap, GError **error)
{
GDBusMessage *reply;
gchar *out_params_type = (gchar *) out_params;
gboolean success = FALSE;
GVariant *v;
reply = g_dbus_connection_send_message_with_reply_finish(client->connection,
result, error);
if (cancel_serial) {
GDBusMessage *message;
message = g_dbus_message_new_method_call (EAS_SERVICE_NAME,
EAS_SERVICE_COMMON_OBJECT_PATH,
EAS_SERVICE_COMMON_INTERFACE,
"cancel_request");
g_dbus_message_set_body (message,
g_variant_new ("(su)",
client->account_uid,
cancel_serial));
g_dbus_connection_send_message (client->connection,
message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
NULL, NULL);
g_object_unref (message);
}
if (!reply)
return FALSE;
/* g_variant_is_of_type() will fail to match a DBus return
of (sas) with a format string of (s^as), where the ^ is
required to make it convert to a strv instead of something
more complicated. So we remove all ^ characters from the
string that we show to g_variant_is_of_type(). Ick. */
if (out_params && strchr (out_params, '^')) {
gchar *x, *y;
out_params_type = g_strdup (out_params);
x = y = strchr (out_params_type, '^');
y++;
while (*y) {
if (*y == '^')
y++;
else
*(x++) = *(y++);
}
*x = 0;
}
switch (g_dbus_message_get_message_type (reply)) {
case G_DBUS_MESSAGE_TYPE_METHOD_RETURN:
/* An empty (successful) response will give a NULL GVariant here */
v = g_dbus_message_get_body (reply);
if (!out_params) {
if (v)
goto inval;
else {
success = TRUE;
break;
}
}
if (!g_variant_is_of_type (v, G_VARIANT_TYPE (out_params_type))) {
inval:
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
"ActiveSync DBus call returned invalid response type %s",
v?g_variant_get_type_string (v):"()");
goto out;
g_object_unref (reply);
}
g_variant_get_va (v, out_params, NULL, ap);
success = TRUE;
break;
case G_DBUS_MESSAGE_TYPE_ERROR:
g_dbus_message_to_gerror (reply, error);
break;
default:
g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
"EAS DBus call returned weird message type %d",
g_dbus_message_get_message_type (reply));
break;
}
out:
if (out_params_type != out_params)
g_free (out_params_type);
g_object_unref (reply);
return success;
}
