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; }