/** * D-Bus callback for the ALS disabling method call * * @param msg The D-Bus message * @return TRUE */ static gboolean als_disable_req_dbus_cb(DBusMessage *const msg) { const char *sender; gssize retval; if( !(sender = dbus_message_get_sender(msg)) ) goto EXIT; mce_log(LL_DEBUG, "Received ALS disable request from %s", sender); retval = mce_dbus_owner_monitor_remove(sender, &ext_als_enablers); if (retval == -1) { mce_log(LL_INFO, "Failed to remove name owner monitoring" " for `%s'",sender); goto EXIT; } rethink_als_status(); EXIT: if( !dbus_message_get_no_reply(msg) ) { DBusMessage *reply = dbus_new_method_reply(msg); dbus_send_message(reply), reply = 0; } return TRUE; }
/** D-Bus callback for the MCE_CPU_KEEPALIVE_WAKEUP_REQ method call * * @param msg The D-Bus message * * @return TRUE on success, FALSE on failure */ static gboolean cka_dbus_handle_wakeup_cb(DBusMessage *const msg) { gboolean success = FALSE; const char *sender = 0; if( !(sender = dbus_message_get_sender(msg)) ) { goto EXIT; } mce_log(LL_NOTICE, "got keepalive wakeup from %s", mce_dbus_get_name_owner_ident(sender)); cka_clients_handle_wakeup(sender); success = TRUE; EXIT: cka_dbusutil_reply_bool(msg, success); return success; }
static DBusMessage *remove_proxy(DBusConnection *conn, DBusMessage *msg, void *data) { struct serial_adapter *adapter = data; struct serial_proxy *prx; const char *path, *sender; GSList *l; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &path, DBUS_TYPE_INVALID)) return NULL; l = g_slist_find_custom(adapter->proxies, path, proxy_pathcmp); if (!l) return does_not_exist(msg, "Invalid proxy path"); prx = l->data; sender = dbus_message_get_sender(msg); if (g_strcmp0(prx->owner, sender) != 0) return failed(msg, "Permission denied"); unregister_proxy(prx); return dbus_message_new_method_return(msg); }
static DBusMessage *unregister_agent(DBusConnection *conn, DBusMessage *msg, void *data) { const char *path, *sender; if (!agent) return agent_does_not_exist(msg); if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return invalid_args(msg); if (strcmp(agent->path, path) != 0) return agent_does_not_exist(msg); sender = dbus_message_get_sender(msg); if (strcmp(agent->bus_name, sender) != 0) return not_authorized(msg); g_dbus_remove_watch(conn, agent->watch_id); agent_free(agent); agent = NULL; DBG("Agent unregistered"); return dbus_message_new_method_return(msg); }
static DBusMessage *unregister_advertisement(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct btd_advertising *manager = user_data; DBusMessageIter args; struct advertisement *ad; struct dbus_obj_match match; DBG("UnregisterAdvertisement"); if (!dbus_message_iter_init(msg, &args)) return btd_error_invalid_args(msg); if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_OBJECT_PATH) return btd_error_invalid_args(msg); dbus_message_iter_get_basic(&args, &match.path); match.owner = dbus_message_get_sender(msg); ad = queue_find(manager->ads, match_advertisement, &match); if (!ad) return btd_error_does_not_exist(msg); advertisement_remove(ad); return dbus_message_new_method_return(msg); }
static DBusMessage *register_server(DBusConnection *conn, DBusMessage *msg, void *data) { struct network_server *ns = data; DBusMessage *reply; const char *uuid, *bridge; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &uuid, DBUS_TYPE_STRING, &bridge, DBUS_TYPE_INVALID)) return NULL; if (g_strcmp0(uuid, "nap")) return btd_error_failed(msg, "Invalid UUID"); if (ns->record_id) return btd_error_already_exists(msg); reply = dbus_message_new_method_return(msg); if (!reply) return NULL; ns->record_id = register_server_record(ns); if (!ns->record_id) return btd_error_failed(msg, "SDP record registration failed"); g_free(ns->bridge); ns->bridge = g_strdup(bridge); ns->watch_id = g_dbus_add_disconnect_watch(conn, dbus_message_get_sender(msg), server_disconnect, ns, NULL); return reply; }
int __connman_session_destroy(DBusMessage *msg) { const char *owner, *session_path; struct connman_session *session; owner = dbus_message_get_sender(msg); DBG("owner %s", owner); dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &session_path, DBUS_TYPE_INVALID); if (session_path == NULL) return -EINVAL; session = g_hash_table_lookup(session_hash, session_path); if (session == NULL) return -EINVAL; if (g_strcmp0(owner, session->owner) != 0) return -EACCES; connman_session_destroy(session); return 0; }
static DBusMessage * service_introspect (GkdSecretService *self, DBusMessage *message) { GPtrArray *names; DBusMessage *reply; ServiceClient *client; const gchar *caller; const gchar *path; GHashTableIter iter; names = g_ptr_array_new_with_free_func (g_free); gkd_secret_objects_foreach_collection (self->objects, message, on_each_path_append_to_array, names); /* Lookup all sessions and prompts for this client */ caller = dbus_message_get_sender (message); if (caller != NULL) { client = g_hash_table_lookup (self->clients, caller); if (client != NULL) { g_hash_table_iter_init (&iter, client->dispatch); while (g_hash_table_iter_next (&iter, (gpointer *)&path, NULL)) g_ptr_array_add (names, g_strdup (path)); } } g_ptr_array_add (names, NULL); reply = gkd_dbus_introspect_handle (message, gkd_secret_introspect_service, (const gchar **)names->pdata); g_ptr_array_unref (names); return reply; }
static DBusMessage *remove_session(DBusConnection *connection, DBusMessage *message, void *user_data) { struct obc_session *session; const char *sender, *path; if (dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) == FALSE) return g_dbus_create_error(message, ERROR_INTERFACE ".InvalidArguments", NULL); session = find_session(path); if (session == NULL) return g_dbus_create_error(message, ERROR_INTERFACE ".InvalidArguments", NULL); sender = dbus_message_get_sender(message); if (g_str_equal(sender, obc_session_get_owner(session)) == FALSE) return g_dbus_create_error(message, ERROR_INTERFACE ".NotAuthorized", "Not Authorized"); release_session(session); return dbus_message_new_method_return(message); }
static DBusMessage* service_method_change_lock (GkdSecretService *self, DBusMessage *message) { GkdSecretChange *change; DBusMessage *reply; const char *caller; const gchar *path; GckObject *collection; caller = dbus_message_get_sender (message); if (!dbus_message_get_args (message, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return NULL; /* Make sure it exists */ collection = gkd_secret_objects_lookup_collection (self->objects, caller, path); if (!collection) return dbus_message_new_error (message, SECRET_ERROR_NO_SUCH_OBJECT, "The collection does not exist"); g_object_unref (collection); change = gkd_secret_change_new (self, caller, path); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (change)); gkd_secret_service_publish_dispatch (self, caller, GKD_SECRET_DISPATCH (change)); reply = dbus_message_new_method_return (message); dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); g_object_unref (change); return reply; }
static DBusMessage* service_method_read_alias (GkdSecretService *self, DBusMessage *message) { DBusMessage *reply; const char *alias; gchar *path = NULL; const gchar *identifier; GckObject *collection = NULL; if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &alias, DBUS_TYPE_INVALID)) return NULL; identifier = gkd_secret_service_get_alias (self, alias); if (identifier) path = gkd_secret_util_build_path (SECRET_COLLECTION_PREFIX, identifier, -1); /* Make sure it actually exists */ if (path) collection = gkd_secret_objects_lookup_collection (self->objects, dbus_message_get_sender (message), path); if (collection == NULL) { g_free (path); path = NULL; } else { g_object_unref (collection); } reply = dbus_message_new_method_return (message); if (path == NULL) path = g_strdup ("/"); dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); g_free (path); return reply; }
static DBusMessage *cancel_authorization(DBusConnection *conn, DBusMessage *msg, void *data) { DBusMessage *reply; struct service_adapter *serv_adapter = data; struct pending_auth *auth; const gchar *sender; sender = dbus_message_get_sender(msg); auth = find_pending_by_sender(serv_adapter, sender); if (auth == NULL) return btd_error_does_not_exist(msg); btd_cancel_authorization(auth->id); reply = btd_error_not_authorized(auth->msg); dbus_message_unref(auth->msg); g_dbus_send_message(btd_get_dbus_connection(), reply); serv_adapter->pending_list = g_slist_remove(serv_adapter->pending_list, auth); g_free(auth); auth = next_pending(serv_adapter); if (auth == NULL) goto done; auth->id = btd_request_authorization(get_address(serv_adapter), &auth->dst, auth->uuid, auth_cb, serv_adapter); done: return dbus_message_new_method_return(msg); }
static DBusMessage *add_service_record(DBusConnection *conn, DBusMessage *msg, void *data) { struct service_adapter *serv_adapter = data; DBusMessage *reply; const char *sender, *record; dbus_uint32_t handle; int err; if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &record, DBUS_TYPE_INVALID) == FALSE) return btd_error_invalid_args(msg); sender = dbus_message_get_sender(msg); err = add_xml_record(sender, serv_adapter, record, &handle); if (err < 0) return btd_error_failed(msg, strerror(-err)); reply = dbus_message_new_method_return(msg); if (!reply) return NULL; dbus_message_append_args(reply, DBUS_TYPE_UINT32, &handle, DBUS_TYPE_INVALID); return reply; }
static DBusMessage *update_xml_record(DBusMessage *msg, struct service_adapter *serv_adapter) { struct record_data *user_record; sdp_record_t *sdp_record; const char *record; dbus_uint32_t handle; int len; if (dbus_message_get_args(msg, NULL, DBUS_TYPE_UINT32, &handle, DBUS_TYPE_STRING, &record, DBUS_TYPE_INVALID) == FALSE) return btd_error_invalid_args(msg); len = (record ? strlen(record) : 0); if (len == 0) return btd_error_invalid_args(msg); user_record = find_record(serv_adapter, handle, dbus_message_get_sender(msg)); if (!user_record) return btd_error_not_available(msg); sdp_record = sdp_xml_parse_record(record, len); if (!sdp_record) { error("Parsing of XML service record failed"); return btd_error_failed(msg, "Parsing of XML service record failed"); } return update_record(msg, serv_adapter, handle, sdp_record); }
static DBusMessage *register_watcher(DBusConnection *conn, DBusMessage *msg, void *data) { struct heartrate_adapter *hradapter = data; struct watcher *watcher; const char *sender = dbus_message_get_sender(msg); char *path; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return btd_error_invalid_args(msg); watcher = find_watcher(hradapter->watchers, sender, path); if (watcher != NULL) return btd_error_already_exists(msg); watcher = g_new0(struct watcher, 1); watcher->hradapter = hradapter; watcher->id = g_dbus_add_disconnect_watch(conn, sender, watcher_exit_cb, watcher, destroy_watcher); watcher->srv = g_strdup(sender); watcher->path = g_strdup(path); if (g_slist_length(hradapter->watchers) == 0) g_slist_foreach(hradapter->devices, enable_measurement, 0); hradapter->watchers = g_slist_prepend(hradapter->watchers, watcher); DBG("heartrate watcher [%s] registered", path); return dbus_message_new_method_return(msg); }
static DBusMessage *release_agent(DBusConnection *connection, DBusMessage *message, void *user_data) { struct session_data *session = user_data; struct agent_data *agent = session->agent; const gchar *sender; gchar *path; if (dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) == FALSE) return g_dbus_create_error(message, "org.openobex.Error.InvalidArguments", "Invalid arguments in method call"); sender = dbus_message_get_sender(message); if (agent == NULL || g_str_equal(sender, agent->name) == FALSE || g_str_equal(path, agent->path) == FALSE) return g_dbus_create_error(message, "org.openobex.Error.NotAuthorized", "Not Authorized"); agent_free(session); return dbus_message_new_method_return(message); }
static DBusMessage *unregister_watcher(DBusConnection *conn, DBusMessage *msg, void *data) { struct heartrate_adapter *hradapter = data; struct watcher *watcher; const char *sender = dbus_message_get_sender(msg); char *path; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return btd_error_invalid_args(msg); watcher = find_watcher(hradapter->watchers, sender, path); if (watcher == NULL) return btd_error_does_not_exist(msg); hradapter->watchers = g_slist_remove(hradapter->watchers, watcher); g_dbus_remove_watch(conn, watcher->id); if (g_slist_length(hradapter->watchers) == 0) g_slist_foreach(hradapter->devices, disable_measurement, 0); DBG("heartrate watcher [%s] unregistered", path); return dbus_message_new_method_return(msg); }
static DBusMessage* service_method_open_session (GkdSecretService *self, DBusMessage *message) { GkdSecretSession *session; ServiceClient *client; DBusMessage *reply = NULL; const gchar *caller; const gchar *path; if (!dbus_message_has_signature (message, "sv")) return NULL; caller = dbus_message_get_sender (message); /* Now we can create a session with this information */ session = gkd_secret_session_new (self, caller); reply = gkd_secret_session_handle_open (session, message); if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_METHOD_RETURN) { /* Take ownership of the session */ client = g_hash_table_lookup (self->clients, caller); g_return_val_if_fail (client, NULL); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (session)); g_return_val_if_fail (!g_hash_table_lookup (client->sessions, path), NULL); g_hash_table_replace (client->sessions, (gpointer)path, session); } else { g_object_unref (session); } return reply; }
static DBusHandlerResult default_message_filter ( DBusConnection *connection, DBusMessage *message, void *p ) { DBusConnectionState *cs = p; uint32_t type =dbus_message_get_type( message ), serial =dbus_message_get_serial( message ); uint8_t reply =dbus_message_get_no_reply( message )==0; const char *path = dbus_message_get_path( message ), *dest = dbus_message_get_destination( message ), *member = dbus_message_get_member( message ), *interface=dbus_message_get_interface( message ), *sender =dbus_message_get_sender( message ), *signature=dbus_message_get_signature( message ); connection = connection; if(cs->mf) return (*(cs->mf))( cs, type, reply, serial, dest, path, member, interface, 0L, sender, signature, message, 0L, 0L, 0L, cs->def_mf_obj ) ; return HANDLED; }
static DBusMessage* service_method_change_lock (GkdSecretService *self, DBusMessage *message) { GkdSecretChange *change; ServiceClient *client; DBusMessage *reply; const char *caller; const gchar *path; GP11Object *collection; caller = dbus_message_get_sender (message); if (!dbus_message_get_args (message, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return NULL; /* Make sure it exists */ collection = gkd_secret_objects_lookup_collection (self->objects, caller, path); if (!collection) return dbus_message_new_error (message, SECRET_ERROR_NO_SUCH_OBJECT, "The collection does not exist"); g_object_unref (collection); change = gkd_secret_change_new (self, caller, path); client = g_hash_table_lookup (self->clients, caller); g_return_val_if_fail (client, NULL); path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (change)); g_hash_table_replace (client->prompts, (gpointer)path, g_object_ref (change)); reply = dbus_message_new_method_return (message); dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); g_object_unref (change); return reply; }
static DBusMessage *register_agent(DBusConnection *conn, DBusMessage *msg, void *data) { const char *path, *sender; if (agent) return agent_already_exists(msg); if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return invalid_args(msg); sender = dbus_message_get_sender(msg); agent = g_new0(struct agent, 1); agent->bus_name = g_strdup(sender); agent->path = g_strdup(path); agent->watch_id = g_dbus_add_disconnect_watch(conn, sender, agent_disconnected, NULL, NULL); DBG("Agent registered"); return dbus_message_new_method_return(msg); }
static DBusMessage *register_agent(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct agent *agent; const char *sender, *path, *capability; uint8_t cap; sender = dbus_message_get_sender(msg); agent = g_hash_table_lookup(agent_list, sender); if (agent) return btd_error_already_exists(msg); if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_STRING, &capability, DBUS_TYPE_INVALID) == FALSE) return btd_error_invalid_args(msg); cap = parse_io_capability(capability); if (cap == IO_CAPABILITY_INVALID) return btd_error_invalid_args(msg); agent = agent_create(sender, path, cap); if (!agent) return btd_error_invalid_args(msg); DBG("agent %s", agent->owner); g_hash_table_replace(agent_list, agent->owner, agent); return dbus_message_new_method_return(msg); }
/** * D-Bus callback for the remove activity callback method call * * @param msg The D-Bus message * @return TRUE on success, FALSE on failure */ static gboolean remove_activity_callback_dbus_cb(DBusMessage *const msg) { dbus_bool_t no_reply = dbus_message_get_no_reply(msg); const gchar *sender = dbus_message_get_sender(msg); gboolean status = FALSE; if (sender == NULL) { mce_log(LL_ERR, "Received invalid remove activity callback request " "(sender == NULL)"); goto EXIT; } mce_log(LL_DEVEL, "Received remove activity callback request from %s", mce_dbus_get_name_owner_ident(sender)); status = TRUE; remove_activity_cb(sender); EXIT: if (no_reply == FALSE) { DBusMessage *reply = dbus_new_method_reply(msg); status = dbus_send_message(reply); } else { status = TRUE; } return status; }
static DBusMessage *unregister_agent(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct agent *agent; const char *sender, *path; sender = dbus_message_get_sender(msg); agent = g_hash_table_lookup(agent_list, sender); if (!agent) return btd_error_does_not_exist(msg); DBG("agent %s", agent->owner); if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID) == FALSE) return btd_error_invalid_args(msg); if (g_str_equal(path, agent->path) == FALSE) return btd_error_does_not_exist(msg); agent_disconnect(conn, agent); return dbus_message_new_method_return(msg); }
static DBusMessage *stk_register_agent(DBusConnection *conn, DBusMessage *msg, void *data) { struct ofono_stk *stk = data; const char *agent_path; if (stk->default_agent) return __ofono_error_busy(msg); if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &agent_path, DBUS_TYPE_INVALID) == FALSE) return __ofono_error_invalid_args(msg); if (!__ofono_dbus_valid_object_path(agent_path)) return __ofono_error_invalid_format(msg); stk->default_agent = stk_agent_new(agent_path, dbus_message_get_sender(msg), FALSE); if (!stk->default_agent) return __ofono_error_failed(msg); stk_agent_set_removed_notify(stk->default_agent, default_agent_notify, stk); if (!stk->session_agent) stk->current_agent = stk->default_agent; return dbus_message_new_method_return(msg); }
static DBusMessage *register_player(DBusConnection *conn, DBusMessage *msg, void *data) { struct media_adapter *adapter = data; struct media_player *mp; DBusMessageIter args; const char *sender, *path; int err; sender = dbus_message_get_sender(msg); dbus_message_iter_init(msg, &args); dbus_message_iter_get_basic(&args, &path); dbus_message_iter_next(&args); if (media_adapter_find_player(adapter, sender, path) != NULL) return btd_error_already_exists(msg); mp = media_player_create(adapter, sender, path, &err); if (mp == NULL) { if (err == -EPROTONOSUPPORT) return btd_error_not_supported(msg); else return btd_error_invalid_args(msg); } if (parse_player_properties(mp, &args) == FALSE) { media_player_destroy(mp); return btd_error_invalid_args(msg); } return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); }
static const char *get_dbus_sender(struct connman_peer *peer) { if (!peer->pending) return NULL; return dbus_message_get_sender(peer->pending); }
static DBusMessage * impl_Embedded (DBusConnection *bus, DBusMessage *message, void *user_data) { AtkObject *object = (AtkObject *) user_data; char *path; gchar *id; if (!dbus_message_get_args (message, NULL, DBUS_TYPE_STRING, &path, DBUS_TYPE_INVALID)) { return droute_invalid_arguments_error (message); } id = g_strconcat (dbus_message_get_sender (message), ":", path, NULL); g_object_set_data_full (G_OBJECT (object), "dbus-plug-parent", id, (GDestroyNotify)g_free); if (ATK_IS_COMPONENT (object)) { AtkComponent *component = ATK_COMPONENT (object); AtkComponentIface *iface = ATK_COMPONENT_GET_IFACE (component); iface->get_extents = atspi_plug_component_get_extents; iface->get_size = atspi_plug_component_get_size; iface->get_position = atspi_plug_component_get_position; } /* Retrieve some info about the children, if they exist, when embedding the plug to ensure the a11y subtree is generated. https://bugzilla.gnome.org/show_bug.cgi?id=663876 */ atk_object_get_n_accessible_children (object); return dbus_message_new_method_return (message); }
/** D-Bus message filter for handling NameOwnerChanged signals * * @param con dbus connection * @param msg message to be acted upon * @param user_data (not used) * * @return DBUS_HANDLER_RESULT_NOT_YET_HANDLED (other filters see the msg too) */ static DBusHandlerResult cpu_keepalive_dbus_filter_cb(DBusConnection *con, DBusMessage *msg, void *user_data) { (void)user_data; DBusHandlerResult res = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; const char *sender = 0; const char *object = 0; const char *name = 0; const char *prev = 0; const char *curr = 0; DBusError err = DBUS_ERROR_INIT; if( con != systembus ) { goto EXIT; } if( !dbus_message_is_signal(msg, DBUS_INTERFACE_DBUS, "NameOwnerChanged") ) { goto EXIT; } sender = dbus_message_get_sender(msg); if( strcmp(sender, DBUS_SERVICE_DBUS) ) { goto EXIT; } object = dbus_message_get_path(msg); if( strcmp(object, DBUS_PATH_DBUS) ) { goto EXIT; } if( !dbus_message_get_args(msg, &err, DBUS_TYPE_STRING, &name, DBUS_TYPE_STRING, &prev, DBUS_TYPE_STRING, &curr, DBUS_TYPE_INVALID) ) { mce_log(LL_WARN, "%s: %s", err.name, err.message); goto EXIT; } if( !*curr ) { mce_log(LL_INFO, "name lost owner: %s", name); cpu_keepalive_remove_client(name); } EXIT: dbus_error_free(&err); return res; }
static DBusHandlerResult message_filter(DBusConnection *connection, DBusMessage *message, void *user_data) { GDBusClient *client = user_data; const char *sender, *path, *interface; if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; sender = dbus_message_get_sender(message); if (sender == NULL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; path = dbus_message_get_path(message); interface = dbus_message_get_interface(message); if (g_str_has_prefix(path, client->base_path) == FALSE) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (g_str_equal(interface, DBUS_INTERFACE_PROPERTIES) == TRUE) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (client->signal_func) client->signal_func(connection, message, client->signal_data); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }