static void media_owner_remove(struct media_owner *owner) { struct media_transport *transport = owner->transport; struct media_request *req = owner->pending; if (!req) return; DBG("Owner %s Request %s", owner->name, dbus_message_get_member(req->msg)); if (req->id) transport->cancel(transport, req->id); owner->pending = NULL; if (req->msg) dbus_message_unref(req->msg); g_free(req); }
/** * wpas_dispatch_bssid_method - dispatch messages for scanned networks * @message: the incoming dbus message * @wpa_s: a network interface's data * @bssid: bssid of the scanned network we're interested in * Returns: a reply dbus message, or a dbus error message * * This function dispatches all incoming dbus messages for scanned networks. */ static DBusMessage * wpas_dispatch_bssid_method(DBusMessage *message, struct wpa_supplicant *wpa_s, const char *bssid) { DBusMessage *reply = NULL; const char *method = dbus_message_get_member(message); struct wpa_scan_result * res = NULL; int i; /* Ensure we actually have scan data */ if (wpa_s->scan_results == NULL && wpa_supplicant_get_scan_results(wpa_s) < 0) { reply = wpas_dbus_new_invalid_bssid_error(message); goto out; } /* Find the bssid's scan data */ for (i = 0; i < wpa_s->num_scan_results; i++) { struct wpa_scan_result * search_res = &wpa_s->scan_results[i]; char mac_str[18]; memset(mac_str, 0, sizeof(mac_str)); snprintf(mac_str, sizeof(mac_str) - 1, WPAS_DBUS_BSSID_FORMAT, MAC2STR(search_res->bssid)); if (!strcmp(bssid, mac_str)) { res = search_res; } } if (!res) { reply = wpas_dbus_new_invalid_bssid_error(message); goto out; } /* Dispatch the method call against the scanned bssid */ if (!strcmp(method, "properties")) reply = wpas_dbus_bssid_properties(message, wpa_s, res); out: return reply; }
DBusHandlerResult timer_adaptor::handle_message(DBusConnection* connection, DBusMessage* message) { std::clog << __FUNCTION__ << std::endl; assert(dbus_message_has_interface(message, INTERFACE_NAME)); auto dst = dbus_message_get_path(message); if (dst == nullptr || strlen(dst) == 0) { std::cerr << "Unknown message destination" << std::endl; return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } auto obj = m_objects.find(dst); if (obj == m_objects.end()) { std::cerr << "Destination object " << dst << " not found" << std::endl; return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } auto name = dbus_message_get_member(message); if (name == nullptr || strlen(name) == 0) { std::cerr << "Unknown method name " << std::endl; return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } typedef dboost::dbus_ptr<DBusMessage> (timer_adaptor::*caller)(timer*, DBusMessage*); typedef std::map<std::string, caller> caller_table; static const caller_table vtbl { {"add_timer", &timer_adaptor::call_add_timer}, {"remove_timer", &timer_adaptor::call_remove_timer} }; auto func = vtbl.find(name); if (func == vtbl.end()) { std::cerr << "Wrong method name " << name << std::endl; return DBUS_HANDLER_RESULT_HANDLED; } auto result = (this->*func->second)(obj->second, message); std::clog << "Reply result" << std::endl; dbus_connection_send(connection, result.get(), 0); return DBUS_HANDLER_RESULT_HANDLED; }
DBusHandlerResult hid_event_filter(DBusMessage *msg, JNIEnv *env) { DBusError err; if (!nat) { LOGV("... skipping %s\n", __FUNCTION__); LOGV("... ignored\n"); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } dbus_error_init(&err); if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) { return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (dbus_message_is_signal(msg, "org.bluez.Input", "PropertyChanged")) { jobjectArray str_array = parse_property_change(env, msg, (Properties *)&input_properties, sizeof(input_properties) / sizeof(Properties)); const char *c_path = dbus_message_get_path(msg); env->CallVoidMethod(nat->me, method_onInputPropertyChanged, env->NewStringUTF(c_path), str_array); result = DBUS_HANDLER_RESULT_HANDLED; return result; } else { LOGV("... ignored"); } if (env->ExceptionCheck()) { LOGE("VM Exception occurred while handling %s.%s (%s) in %s," " leaving for VM", dbus_message_get_interface(msg), dbus_message_get_member(msg), dbus_message_get_path(msg), __FUNCTION__); } return result; }
WhiteBoardCmd* whiteboard_cmd_new_response(WhiteBoardCmd* request) { WhiteBoardCmd* self = NULL; const gchar *member = NULL; const gchar* begin = WHITEBOARD_CMD_DATA_BEGIN; whiteboard_log_debug_fb(); g_return_val_if_fail(request != NULL, NULL); g_return_val_if_fail(request->msg != NULL, NULL); self = g_new0(WhiteBoardCmd, 1); g_return_val_if_fail(self != NULL, NULL); self->refcount = 1; self->msg = dbus_message_new_method_return(request->msg); g_return_val_if_fail(self->msg != NULL, NULL); /* The response message is directed back to the whiteboard generic I/F */ dbus_message_set_interface(self->msg, WHITEBOARD_DBUS_INTERFACE); /* Copy member name from the request to this response */ member = dbus_message_get_member(request->msg); dbus_message_set_member(self->msg, member); /* Copy method name from the request to the response */ whiteboard_cmd_append_method_name(self, whiteboard_cmd_get_method_name(request)); /* Copy target UUID from the request to the response */ whiteboard_cmd_append_target_uuid(self, whiteboard_cmd_get_target_uuid(request)); dbus_message_append_args(self->msg, DBUS_TYPE_STRING, &begin, DBUS_TYPE_INVALID); whiteboard_log_debug_fe(); return (WhiteBoardCmdResponse*) self; }
NS_IMETHOD Run() { if (dbus_message_get_path(mMsg.get()) == NULL) { return NS_OK; } MOZ_ASSERT(NS_IsMainThread()); // Notify observers that a message has been sent nsDependentCString path(dbus_message_get_path(mMsg.get())); nsDependentCString member(dbus_message_get_member(mMsg.get())); BluetoothEventObserverList *ol; if (!sBluetoothEventObserverTable->Get(path, &ol)) { LOG("No objects registered for %s, returning\n", dbus_message_get_path(mMsg.get())); return NS_OK; } BluetoothEvent e; e.mEventName = member; ol->Broadcast(e); return NS_OK; }
DBusHandlerResult asdbus_handle_message (DBusConnection * conn, DBusMessage * msg, void *data) { Bool handled = False; show_progress ("Dbus message received from \"%s\", member \"%s\"", dbus_message_get_interface (msg), dbus_message_get_member (msg)); if (dbus_message_is_signal (msg, "org.gnome.SessionManager", "SessionOver")) { dbus_message_unref (msg); handled = True; Done (False, NULL); } return handled ? DBUS_HANDLER_RESULT_HANDLED : DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
/** * wpas_dispatch_network_method - dispatch messages for configured networks * @message: the incoming dbus message * @wpa_s: a network interface's data * @network_id: id of the configured network we're interested in * Returns: a reply dbus message, or a dbus error message * * This function dispatches all incoming dbus messages for configured networks. */ static DBusMessage * wpas_dispatch_network_method(DBusMessage *message, struct wpa_supplicant *wpa_s, int network_id) { DBusMessage *reply = NULL; const char *method = dbus_message_get_member(message); struct wpa_ssid *ssid; ssid = wpa_config_get_network(wpa_s->conf, network_id); if (ssid == NULL) return wpas_dbus_new_invalid_network_error(message); if (!strcmp(method, "set")) reply = wpas_dbus_iface_set_network(message, wpa_s, ssid); else if (!strcmp(method, "enable")) reply = wpas_dbus_iface_enable_network(message, wpa_s, ssid); else if (!strcmp(method, "disable")) reply = wpas_dbus_iface_disable_network(message, wpa_s, ssid); return reply; }
static DBusHandlerResult handle_message(DBusConnection* conn, DBusMessage* msg, void* user_data) { const char* member = dbus_message_get_member(msg); VERB1 log("%s(member:'%s')", __func__, member); int type = dbus_message_get_type(msg); if (type != DBUS_MESSAGE_TYPE_SIGNAL) { log("The message is not a signal. ignoring"); return DBUS_HANDLER_RESULT_HANDLED; } if (strcmp(member, "NameOwnerChanged") == 0) NameOwnerChanged(msg); else if (strcmp(member, "Crash") == 0) Crash(msg); else if (strcmp(member, "QuotaExceeded") == 0) QuotaExceeded(msg); return DBUS_HANDLER_RESULT_HANDLED; }
static DBusHandlerResult profile_handler(DBusConnection *c, DBusMessage *m, void *userdata) { pa_bluetooth_backend *b = userdata; DBusMessage *r = NULL; const char *path, *interface, *member; pa_assert(b); path = dbus_message_get_path(m); interface = dbus_message_get_interface(m); member = dbus_message_get_member(m); pa_log_debug("dbus: path=%s, interface=%s, member=%s", path, interface, member); if (!pa_streq(path, HSP_AG_PROFILE) && !pa_streq(path, HSP_HS_PROFILE)) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (dbus_message_is_method_call(m, "org.freedesktop.DBus.Introspectable", "Introspect")) { const char *xml = PROFILE_INTROSPECT_XML; pa_assert_se(r = dbus_message_new_method_return(m)); pa_assert_se(dbus_message_append_args(r, DBUS_TYPE_STRING, &xml, DBUS_TYPE_INVALID)); } else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "Release")) { pa_log_debug("Release not handled"); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "RequestDisconnection")) { r = profile_request_disconnection(c, m, userdata); } else if (dbus_message_is_method_call(m, BLUEZ_PROFILE_INTERFACE, "NewConnection")) r = profile_new_connection(c, m, userdata); else return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (r) { pa_assert_se(dbus_connection_send(pa_dbus_connection_get(b->connection), r, NULL)); dbus_message_unref(r); } return DBUS_HANDLER_RESULT_HANDLED; }
DBusHandlerResult watch_signal(DBusConnection* connection, DBusMessage *msg, void *no_use) { if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; const char* iface = dbus_message_get_interface(msg); const char* s_name = dbus_message_get_member(msg); const char* path = dbus_message_get_path(msg); char* key = g_strdup_printf("%s%s%s", path, iface, s_name); GHashTable* cbs_info = g_hash_table_lookup(__sig_info_hash, key); g_free(key); if (cbs_info == NULL) { return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } else { g_hash_table_foreach(cbs_info, (GHFunc)handle_signal_callback, msg); return DBUS_HANDLER_RESULT_HANDLED; } }
/* Callback: "a message is received to a registered object path" */ static DBusHandlerResult message_received(DBusConnection* conn, DBusMessage* msg, void* data) { const char* member = dbus_message_get_member(msg); VERB1 log("%s(method:'%s')", __func__, member); set_client_name(dbus_message_get_sender(msg)); DBusMessage* reply = dbus_message_new_method_return(msg); int r = -1; if (strcmp(member, "DeleteDebugDump") == 0) r = handle_DeleteDebugDump(msg, reply); // NB: C++ binding also handles "Introspect" method, which returns a string. // It was sending "dummy" introspection answer whick looks like this: // "<!DOCTYPE node PUBLIC \"-//freedesktop//DTD D-BUS Object Introspection 1.0//EN\"\n" // "\"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd\">\n" // "<node>\n" // "</node>\n" // Apart from a warning from abrt-gui, just sending error back works as well. // NB2: we may want to handle "Disconnected" here too. if (r < 0) { /* handle_XXX experienced an error (and did not send any reply) */ dbus_message_unref(reply); if (dbus_message_get_type(msg) == DBUS_MESSAGE_TYPE_METHOD_CALL) { /* Create and send error reply */ reply = dbus_message_new_error(msg, DBUS_ERROR_FAILED, "not supported"); if (!reply) die_out_of_memory(); send_flush_and_unref(reply); } } set_client_name(NULL); return DBUS_HANDLER_RESULT_HANDLED; }
static DBusHandlerResult handle_chaind_message(DBusConnection* conn, DBusMessage* msg, void* userdata) { const char *interface = dbus_message_get_interface(msg); const char *method = dbus_message_get_member(msg); if(interface != NULL) printf("dbus interface: %s\n", interface); if(method != NULL) printf("dbus method: %s\n", method); if(strcmp(interface, DBUS_INTERFACE_INTROSPECTABLE) == 0) { return handle_chaind_introspection(conn, msg, userdata); } else if(strcmp(interface, "org.sarcharsoftware.chaind") == 0 && method != NULL) { if(strcmp(method, "GetBlock") == 0) { return handle_chaind_get_block(conn, msg, userdata); } else if(strcmp(method, "GetBestBlock") == 0) { return handle_chaind_get_best_block(conn, msg, userdata); } else if(strcmp(method, "GetTransaction") == 0) { return handle_chaind_get_transaction(conn, msg, userdata); } } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
static DBusHandlerResult _handle_message (DBusConnection *connection, DBusMessage *message, void *data) { ServiceData *svc = (ServiceData *)data; DBusHandlerResult result; rb_debug ("handling metadata service message: %s", dbus_message_get_member (message)); if (dbus_message_is_method_call (message, RB_METADATA_DBUS_INTERFACE, "load")) { result = rb_metadata_dbus_load (connection, message, svc); } else if (dbus_message_is_method_call (message, RB_METADATA_DBUS_INTERFACE, "getSaveableTypes")) { result = rb_metadata_dbus_get_saveable_types (connection, message, svc); } else if (dbus_message_is_method_call (message, RB_METADATA_DBUS_INTERFACE, "save")) { result = rb_metadata_dbus_save (connection, message, svc); } else if (dbus_message_is_method_call (message, RB_METADATA_DBUS_INTERFACE, "ping")) { result = rb_metadata_dbus_ping (connection, message, svc); } else { result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } svc->last_active = time (NULL); return result; }
DBusHandlerResult message_handler(DBusConnection *connection, DBusMessage *message, void *user_data) { char *method = (char *)dbus_message_get_member(message); if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) { DBusMessage *reply = dbus_message_new_method_return(message); dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection_xml, DBUS_TYPE_INVALID); dbus_connection_send (connection, reply, NULL); dbus_message_unref (reply); } else if (strcmp(method, "GetVersion") == 0) { char *v = VERSION; DBusMessage *reply = dbus_message_new_method_return(message); dbus_message_append_args(reply, DBUS_TYPE_STRING, &v, DBUS_TYPE_INVALID); dbus_connection_send (connection, reply, NULL); dbus_message_unref (reply); } else if (strcmp(method, "SetServers") == 0) { my_syslog(LOG_INFO, _("setting upstream servers from DBus")); dbus_read_servers(message); check_servers(); } else if (strcmp(method, "ClearCache") == 0) clear_cache_and_reload(dnsmasq_time()); else return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED); method = user_data; return (DBUS_HANDLER_RESULT_HANDLED); }
gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message) { dbus_bool_t result; if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL) dbus_message_set_no_reply(message, TRUE); else if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL) { const char *path = dbus_message_get_path(message); const char *interface = dbus_message_get_interface(message); const char *name = dbus_message_get_member(message); const GDBusArgInfo *args; if (!check_signal(connection, path, interface, name, &args)) return FALSE; } result = dbus_connection_send(connection, message, NULL); dbus_message_unref(message); return result; }
static DBusMessage * properties_handler(DBusMessage *message, struct wpa_dbus_object_desc *obj_dsc) { DBusMessageIter iter; char *interface; const char *method; method = dbus_message_get_member(message); dbus_message_iter_init(message, &iter); if (!os_strncmp(WPA_DBUS_PROPERTIES_GET, method, WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) || !os_strncmp(WPA_DBUS_PROPERTIES_SET, method, WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) || !os_strncmp(WPA_DBUS_PROPERTIES_GETALL, method, WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) { /* First argument: interface name (DBUS_TYPE_STRING) */ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) { return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, NULL); } dbus_message_iter_get_basic(&iter, &interface); if (!os_strncmp(WPA_DBUS_PROPERTIES_GETALL, method, WPAS_DBUS_METHOD_SIGNAL_PROP_MAX)) { /* GetAll */ return properties_get_all(message, interface, obj_dsc); } /* Get or Set */ return properties_get_or_set(message, &iter, interface, obj_dsc); } return dbus_message_new_error(message, DBUS_ERROR_UNKNOWN_METHOD, NULL); }
static DBusMessage *release(DBusConnection *conn, DBusMessage *msg, void *data) { struct media_transport *transport = data; struct media_owner *owner = transport->owner; const char *sender; struct media_request *req; guint id; sender = dbus_message_get_sender(msg); if (owner == NULL || g_strcmp0(owner->name, sender) != 0) return btd_error_not_authorized(msg); if (owner->pending) { const char *member; member = dbus_message_get_member(owner->pending->msg); /* Cancel Acquire request if that exist */ if (g_str_equal(member, "Acquire")) media_owner_remove(owner); else return btd_error_in_progress(msg); } transport_set_state(transport, TRANSPORT_STATE_SUSPENDING); id = transport->suspend(transport, owner); if (id == 0) { media_transport_remove_owner(transport); return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); } req = media_request_create(msg, id); media_owner_add(owner, req); return NULL; }
//! Handles a DBus message and executes related script void handle_message(DBusMessage *msg) { Py_Initialize(); const char *method = dbus_message_get_member(msg); const char *iface = dbus_message_get_interface(msg); const char *path = dbus_message_get_path(msg); log_debug("Forked new process for '%s.%s' - '%s'\n", iface, method, path); if (method == NULL || path == NULL || method == NULL) { bus_reply_unknown_method(msg); } else if (strcmp("org.freedesktop.DBus.Introspectable", iface) == 0 && strcmp("Introspect", method) == 0) { // Introspection method message_execute(msg, NULL, "Core", "introspect"); } else if (strcmp(config_interface, iface) == 0) { // Core methods message_execute(msg, NULL, "Core", method); } else if (strncmp(config_interface, iface, strlen(config_interface)) == 0 && iface[strlen(config_interface)] == '.') { // Model.method char *model = strsub(iface, strlen(config_interface) + 1, strlen(iface)); char *app = strsub(path, strlen("/package/"), strlen(path)); message_execute(msg, app, model, method); free(model); free(app); } else { bus_reply_unknown_method(msg); } Py_Finalize(); }
static DBusMessage * msg_method_handler(DBusMessage *message, struct wpa_dbus_object_desc *obj_dsc) { const struct wpa_dbus_method_desc *method_dsc = obj_dsc->methods; const char *method; const char *msg_interface; method = dbus_message_get_member(message); msg_interface = dbus_message_get_interface(message); /* try match call to any registered method */ while (method_dsc && method_dsc->dbus_method) { /* compare method names and interfaces */ if (!os_strncmp(method_dsc->dbus_method, method, WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) && !os_strncmp(method_dsc->dbus_interface, msg_interface, WPAS_DBUS_INTERFACE_MAX)) break; method_dsc++; } if (method_dsc == NULL || method_dsc->dbus_method == NULL) { wpa_printf(MSG_DEBUG, "no method handler for %s.%s on %s", msg_interface, method, dbus_message_get_path(message)); return dbus_message_new_error(message, DBUS_ERROR_UNKNOWN_METHOD, NULL); } if (!is_signature_correct(message, method_dsc)) { return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, NULL); } return method_dsc->method_handler(message, obj_dsc->user_data); }
DBusHandlerResult watch_signal(DBusConnection* connection, DBusMessage *msg, void *no_use) { if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; const char* iface = dbus_message_get_interface(msg); const char* s_name = dbus_message_get_member(msg); const char* path = dbus_message_get_path(msg); char* key = g_strdup_printf("%s%s%s", path, iface, s_name); struct SignalInfo* info = g_hash_table_lookup(__sig_info_hash, key); g_free(key); if (info == NULL) { return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } else { DBusMessageIter iter; dbus_message_iter_init(msg, &iter); int num = g_slist_length(info->signatures); JSValueRef *params = g_new(JSValueRef, num); for (int i=0; i<num; i++) { params[i] = dbus_to_js(get_global_context(), &iter); if (!dbus_message_iter_next(&iter)) { } } g_assert(info->callback != NULL); JSObjectCallAsFunction(get_global_context(), info->callback, NULL, num, params, NULL); g_free(params); return DBUS_HANDLER_RESULT_HANDLED; } }
static gboolean media_endpoint_async_call(DBusMessage *msg, struct media_endpoint *endpoint, media_endpoint_cb_t cb, void *user_data, GDestroyNotify destroy) { struct endpoint_request *request; request = g_new0(struct endpoint_request, 1); /* Timeout should be less than avdtp request timeout (4 seconds) */ if (dbus_connection_send_with_reply(btd_get_dbus_connection(), msg, &request->call, REQUEST_TIMEOUT) == FALSE) { error("D-Bus send failed"); g_free(request); return FALSE; } dbus_pending_call_set_notify(request->call, endpoint_reply, request, NULL); request->endpoint = endpoint; request->msg = msg; request->cb = cb; request->destroy = destroy; request->user_data = user_data; endpoint->requests = g_slist_append(endpoint->requests, request); DBG("Calling %s: name = %s path = %s", dbus_message_get_member(msg), dbus_message_get_destination(msg), dbus_message_get_path(msg)); return TRUE; }
QDBusMessage QDBusMessage::fromDBusMessage(DBusMessage *dmsg) { QDBusMessage message; if (!dmsg) return message; message.d->type = dbus_message_get_type(dmsg); message.d->path = QString::fromUtf8(dbus_message_get_path(dmsg)); message.d->interface = QString::fromUtf8(dbus_message_get_interface(dmsg)); message.d->member = QString::fromUtf8(dbus_message_get_member(dmsg)); message.d->sender = QString::fromUtf8(dbus_message_get_sender(dmsg)); message.d->msg = dbus_message_ref(dmsg); DBusError dbusError; dbus_error_init(&dbusError); if (dbus_set_error_from_message(&dbusError, dmsg)) { message.d->error = QDBusError(&dbusError); } QDBusMarshall::messageToList(message, dmsg); return message; }
DBusHandlerResult gattclient_event_filter(DBusMessage *msg, JNIEnv *env) { DBusError err; DBusHandlerResult ret; DBusHandlerResult result = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; dbus_error_init(&err); if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) { return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } if (dbus_message_is_signal(msg,"org.bluez.Characteristic", "PropertyChanged")) { LOGV("org.bluez.Characteristic.PropertyChanged"); jobjectArray str_array = parse_remote_characteristic_property_change(env, msg); if (str_array != NULL) { const char *remote_char_path = dbus_message_get_path(msg); env->CallVoidMethod(gnat->me, method_onCharacteristicPropertyChanged, env->NewStringUTF(remote_char_path), str_array); } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); result = DBUS_HANDLER_RESULT_HANDLED; } else { LOGV("... ignored"); } if (env->ExceptionCheck()) { LOGE("VM Exception occurred while handling %s.%s (%s) in %s," " leaving for VM", dbus_message_get_interface(msg), dbus_message_get_member(msg), dbus_message_get_path(msg), __FUNCTION__); } return result; }
OMXControlResult OMXControl::getEvent() { if (!bus) return KeyConfig::ACTION_BLANK; dispatch(); DBusMessage *m = dbus_connection_pop_message(bus); if (m == NULL) return KeyConfig::ACTION_BLANK; CLog::Log(LOGDEBUG, "Popped message member: %s interface: %s type: %d path: %s", dbus_message_get_member(m), dbus_message_get_interface(m), dbus_message_get_type(m), dbus_message_get_path(m) ); if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_ROOT, "Quit")) { dbus_respond_ok(m); return KeyConfig::ACTION_EXIT; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "CanQuit") || dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "Fullscreen")) { dbus_respond_boolean(m, 1); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "CanSetFullscreen") || dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "CanRaise") || dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "HasTrackList")) { dbus_respond_boolean(m, 0); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "Identity")) { dbus_respond_string(m, "OMXPlayer"); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "SupportedUriSchemes")) { const char *UriSchemes[] = {"file", "http"}; dbus_respond_array(m, UriSchemes, 2); // Array is of length 2 return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "SupportedMimeTypes")) { const char *MimeTypes[] = {}; // Needs supplying dbus_respond_array(m, MimeTypes, 0); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "CanGoNext") || dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "CanGoPrevious")) { dbus_respond_boolean(m, 0); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "CanSeek")) { dbus_respond_boolean(m, reader->CanSeek()); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "CanControl") || dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "CanPlay") || dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "CanPause")) { dbus_respond_boolean(m, 1); } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "Next")) { dbus_respond_ok(m); return KeyConfig::ACTION_NEXT_CHAPTER; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "Previous")) { dbus_respond_ok(m); return KeyConfig::ACTION_PREVIOUS_CHAPTER; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "Pause") || dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "PlayPause")) { dbus_respond_ok(m); return KeyConfig::ACTION_PAUSE; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "Stop")) { dbus_respond_ok(m); return KeyConfig::ACTION_EXIT; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "Seek")) { DBusError error; dbus_error_init(&error); int64_t offset; dbus_message_get_args(m, &error, DBUS_TYPE_INT64, &offset, DBUS_TYPE_INVALID); // Make sure a value is sent for seeking if (dbus_error_is_set(&error)) { CLog::Log(LOGWARNING, "Seek D-Bus Error: %s", error.message ); dbus_error_free(&error); dbus_respond_ok(m); return KeyConfig::ACTION_BLANK; } else { dbus_respond_int64(m, offset); return OMXControlResult(KeyConfig::ACTION_SEEK_RELATIVE, offset); } } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "SetPosition")) { DBusError error; dbus_error_init(&error); int64_t position; dbus_message_get_args(m, &error, DBUS_TYPE_INT64, &position, DBUS_TYPE_INVALID); // Make sure a value is sent for setting position if (dbus_error_is_set(&error)) { CLog::Log(LOGWARNING, "SetPosition D-Bus Error: %s", error.message ); dbus_error_free(&error); dbus_respond_ok(m); return KeyConfig::ACTION_BLANK; } else { dbus_respond_int64(m, position); return OMXControlResult(KeyConfig::ACTION_SEEK_ABSOLUTE, position); } } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "PlaybackStatus")) { const char *status; if (clock->OMXIsPaused()) { status = "Paused"; } else { status = "Playing"; } dbus_respond_string(m, status); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "Volume")) { DBusError error; dbus_error_init(&error); double volume; dbus_message_get_args(m, &error, DBUS_TYPE_DOUBLE, &volume, DBUS_TYPE_INVALID); if (dbus_error_is_set(&error)) { // i.e. Get current volume dbus_error_free(&error); dbus_respond_double(m, audio->GetVolume()); return KeyConfig::ACTION_BLANK; } else { audio->SetVolume(volume); dbus_respond_double(m, volume); return KeyConfig::ACTION_BLANK; } } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "Mute")) { audio->SetMute(true); dbus_respond_ok(m); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "Unmute")) { audio->SetMute(false); dbus_respond_ok(m); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "Position")) { // Returns the current position in microseconds int64_t pos = clock->OMXMediaTime(); dbus_respond_int64(m, pos); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "Duration")) { // Returns the duration in microseconds int64_t dur = reader->GetStreamLength(); dur *= 1000; // ms -> us dbus_respond_int64(m, dur); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "MinimumRate")) { dbus_respond_double(m, 0.0); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PROPERTIES, "MaximumRate")) { dbus_respond_double(m, 1.125); return KeyConfig::ACTION_BLANK; // Implement extra OMXPlayer controls } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "ListSubtitles")) { int count = reader->SubtitleStreamCount(); char** values = new char*[count]; for (int i=0; i < count; i++) { asprintf(&values[i], "%d:%s:%s:%s:%s", i, reader->GetStreamLanguage(OMXSTREAM_SUBTITLE, i).c_str(), reader->GetStreamName(OMXSTREAM_SUBTITLE, i).c_str(), reader->GetCodecName(OMXSTREAM_SUBTITLE, i).c_str(), ((int)subtitles->GetActiveStream() == i) ? "active" : ""); } dbus_respond_array(m, (const char**)values, count); // Cleanup for (int i=0; i < count; i++) { delete[] values[i]; } return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "VideoPos")) { DBusError error; dbus_error_init(&error); const char *win; const char *oPath; // ignoring path right now because we don't have a playlist dbus_message_get_args(m, &error, DBUS_TYPE_OBJECT_PATH, &oPath, DBUS_TYPE_STRING, &win, DBUS_TYPE_INVALID); // Make sure a value is sent for setting VideoPos if (dbus_error_is_set(&error)) { CLog::Log(LOGWARNING, "VideoPos D-Bus Error: %s", error.message ); dbus_error_free(&error); dbus_respond_ok(m); return KeyConfig::ACTION_BLANK; } else { dbus_respond_string(m, win); return OMXControlResult(KeyConfig::ACTION_MOVE_VIDEO, win); } } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "HideVideo")) { dbus_respond_ok(m); return KeyConfig::ACTION_HIDE_VIDEO; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "UnHideVideo")) { dbus_respond_ok(m); return KeyConfig::ACTION_UNHIDE_VIDEO; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "ListAudio")) { int count = reader->AudioStreamCount(); char** values = new char*[count]; for (int i=0; i < count; i++) { asprintf(&values[i], "%d:%s:%s:%s:%s", i, reader->GetStreamLanguage(OMXSTREAM_AUDIO, i).c_str(), reader->GetStreamName(OMXSTREAM_AUDIO, i).c_str(), reader->GetCodecName(OMXSTREAM_AUDIO, i).c_str(), (reader->GetAudioIndex() == i) ? "active" : ""); } dbus_respond_array(m, (const char**)values, count); // Cleanup for (int i=0; i < count; i++) { delete[] values[i]; } return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "ListVideo")) { int count = reader->AudioStreamCount(); char** values = new char*[count]; for (int i=0; i < count; i++) { asprintf(&values[i], "%d:%s:%s:%s:%s", i, reader->GetStreamLanguage(OMXSTREAM_VIDEO, i).c_str(), reader->GetStreamName(OMXSTREAM_VIDEO, i).c_str(), reader->GetCodecName(OMXSTREAM_VIDEO, i).c_str(), (reader->GetVideoIndex() == i) ? "active" : ""); } dbus_respond_array(m, (const char**)values, count); // Cleanup for (int i=0; i < count; i++) { delete[] values[i]; } return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "SelectSubtitle")) { DBusError error; dbus_error_init(&error); int index; dbus_message_get_args(m, &error, DBUS_TYPE_INT32, &index, DBUS_TYPE_INVALID); if (dbus_error_is_set(&error)) { dbus_error_free(&error); dbus_respond_boolean(m, 0); } else { if (reader->SetActiveStream(OMXSTREAM_SUBTITLE, index)) { subtitles->SetActiveStream(reader->GetSubtitleIndex()); dbus_respond_boolean(m, 1); } else { dbus_respond_boolean(m, 0); } } return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "SelectAudio")) { DBusError error; dbus_error_init(&error); int index; dbus_message_get_args(m, &error, DBUS_TYPE_INT32, &index, DBUS_TYPE_INVALID); if (dbus_error_is_set(&error)) { dbus_error_free(&error); dbus_respond_boolean(m, 0); } else { if (reader->SetActiveStream(OMXSTREAM_AUDIO, index)) { dbus_respond_boolean(m, 1); } else { dbus_respond_boolean(m, 0); } } return KeyConfig::ACTION_BLANK; } // TODO: SelectVideo ??? else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "ShowSubtitles")) { subtitles->SetVisible(true); dbus_respond_ok(m); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "HideSubtitles")) { subtitles->SetVisible(false); dbus_respond_ok(m); return KeyConfig::ACTION_BLANK; } else if (dbus_message_is_method_call(m, OMXPLAYER_DBUS_INTERFACE_PLAYER, "Action")) { DBusError error; dbus_error_init(&error); int action; dbus_message_get_args(m, &error, DBUS_TYPE_INT32, &action, DBUS_TYPE_INVALID); if (dbus_error_is_set(&error)) { dbus_error_free(&error); dbus_respond_ok(m); return KeyConfig::ACTION_BLANK; } else { dbus_respond_ok(m); return action; // Directly return enum } } else { CLog::Log(LOGWARNING, "Unhandled dbus message, member: %s interface: %s type: %d path: %s", dbus_message_get_member(m), dbus_message_get_interface(m), dbus_message_get_type(m), dbus_message_get_path(m) ); } return KeyConfig::ACTION_BLANK; }
EAPI const char * eldbus_message_member_get(const Eldbus_Message *msg) { ELDBUS_MESSAGE_CHECK_RETVAL(msg, NULL); return dbus_message_get_member(msg->dbus_msg); }
VIR_MOCK_WRAP_RET_ARGS(dbus_connection_send_with_reply_and_block, DBusMessage *, DBusConnection *, connection, DBusMessage *, message, int, timeout_milliseconds, DBusError *, error) { DBusMessage *reply = NULL; const char *service = dbus_message_get_destination(message); const char *member = dbus_message_get_member(message); VIR_MOCK_REAL_INIT(dbus_connection_send_with_reply_and_block); if (STREQ(service, "org.freedesktop.machine1")) { if (getenv("FAIL_BAD_SERVICE")) { dbus_set_error_const(error, "org.freedesktop.systemd.badthing", "Something went wrong creating the machine"); } else { reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); } } else if (STREQ(service, "org.freedesktop.login1")) { char *supported = getenv("RESULT_SUPPORT"); DBusMessageIter iter; reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); dbus_message_iter_init_append(reply, &iter); if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &supported)) goto error; } else if (STREQ(service, "org.freedesktop.DBus") && STREQ(member, "ListActivatableNames")) { const char *svc1 = "org.foo.bar.wizz"; const char *svc2 = "org.freedesktop.machine1"; const char *svc3 = "org.freedesktop.login1"; DBusMessageIter iter; DBusMessageIter sub; reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); dbus_message_iter_init_append(reply, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub); if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &svc1)) goto error; if (!getenv("FAIL_NO_SERVICE") && !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &svc2)) goto error; if (!getenv("FAIL_NO_SERVICE") && !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &svc3)) goto error; dbus_message_iter_close_container(&iter, &sub); } else if (STREQ(service, "org.freedesktop.DBus") && STREQ(member, "ListNames")) { const char *svc1 = "org.foo.bar.wizz"; const char *svc2 = "org.freedesktop.systemd1"; const char *svc3 = "org.freedesktop.login1"; DBusMessageIter iter; DBusMessageIter sub; reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); dbus_message_iter_init_append(reply, &iter); dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub); if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &svc1)) goto error; if ((!getenv("FAIL_NO_SERVICE") && !getenv("FAIL_NOT_REGISTERED")) && !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &svc2)) goto error; if ((!getenv("FAIL_NO_SERVICE") && !getenv("FAIL_NOT_REGISTERED")) && !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &svc3)) goto error; dbus_message_iter_close_container(&iter, &sub); } else { reply = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN); } return reply; error: dbus_message_unref(reply); return NULL; }
/** * wpas_iface_message_handler - Dispatch messages for interfaces or networks * @connection: Connection to the system message bus * @message: An incoming dbus message * @user_data: A pointer to a dbus control interface data structure * Returns: Whether or not the message was handled * * This function dispatches all incoming dbus messages for network interfaces, * or objects owned by them, such as scanned BSSIDs and configured networks. */ static DBusHandlerResult wpas_iface_message_handler(DBusConnection *connection, DBusMessage *message, void *user_data) { struct wpa_supplicant *wpa_s = user_data; const char *method = dbus_message_get_member(message); const char *path = dbus_message_get_path(message); const char *msg_interface = dbus_message_get_interface(message); char *iface_obj_path = NULL; char *network = NULL; char *bssid = NULL; DBusMessage *reply = NULL; /* Caller must specify a message interface */ if (!msg_interface) goto out; iface_obj_path = wpas_dbus_decompose_object_path(path, &network, &bssid); if (iface_obj_path == NULL) { reply = wpas_dbus_new_invalid_iface_error(message); goto out; } /* Make sure the message's object path actually refers to the * wpa_supplicant structure it's supposed to (which is wpa_s) */ if (wpa_supplicant_get_iface_by_dbus_path(wpa_s->global, iface_obj_path) != wpa_s) { reply = wpas_dbus_new_invalid_iface_error(message); goto out; } if (network && !strcmp(msg_interface, WPAS_DBUS_IFACE_NETWORK)) { /* A method for one of this interface's configured networks */ int nid = strtoul(network, NULL, 10); if (errno != EINVAL) reply = wpas_dispatch_network_method(message, wpa_s, nid); else reply = wpas_dbus_new_invalid_network_error(message); } else if (bssid && !strcmp(msg_interface, WPAS_DBUS_IFACE_BSSID)) { /* A method for one of this interface's scanned BSSIDs */ reply = wpas_dispatch_bssid_method(message, wpa_s, bssid); } else if (!strcmp(msg_interface, WPAS_DBUS_IFACE_INTERFACE)) { /* A method for an interface only. */ if (!strcmp(method, "scan")) reply = wpas_dbus_iface_scan(message, wpa_s); else if (!strcmp(method, "scanResults")) reply = wpas_dbus_iface_scan_results(message, wpa_s); else if (!strcmp(method, "addNetwork")) reply = wpas_dbus_iface_add_network(message, wpa_s); else if (!strcmp(method, "removeNetwork")) reply = wpas_dbus_iface_remove_network(message, wpa_s); else if (!strcmp(method, "selectNetwork")) reply = wpas_dbus_iface_select_network(message, wpa_s); else if (!strcmp(method, "capabilities")) reply = wpas_dbus_iface_capabilities(message, wpa_s); else if (!strcmp(method, "disconnect")) reply = wpas_dbus_iface_disconnect(message, wpa_s); else if (!strcmp(method, "setAPScan")) reply = wpas_dbus_iface_set_ap_scan(message, wpa_s); else if (!strcmp(method, "setSmartcardModules")) reply = wpas_dbus_iface_set_smartcard_modules(message, wpa_s); else if (!strcmp(method, "state")) reply = wpas_dbus_iface_get_state(message, wpa_s); else if (!strcmp(method, "scanning")) reply = wpas_dbus_iface_get_scanning(message, wpa_s); else if (!strcmp(method, "setBlobs")) reply = wpas_dbus_iface_set_blobs(message, wpa_s); else if (!strcmp(method, "removeBlobs")) reply = wpas_dbus_iface_remove_blobs(message, wpa_s); #ifdef CONFIG_WPS else if (!os_strcmp(method, "wpsPbc")) reply = wpas_dbus_iface_wps_pbc(message, wpa_s); else if (!os_strcmp(method, "wpsPin")) reply = wpas_dbus_iface_wps_pin(message, wpa_s); else if (!os_strcmp(method, "wpsReg")) reply = wpas_dbus_iface_wps_reg(message, wpa_s); #endif /* CONFIG_WPS */ else if (!os_strcmp(method, "flush")) reply = wpas_dbus_iface_flush(message, wpa_s); } /* If the message was handled, send back the reply */ if (reply) { if (!dbus_message_get_no_reply(message)) dbus_connection_send(connection, reply, NULL); dbus_message_unref(reply); } out: os_free(iface_obj_path); os_free(network); os_free(bssid); return reply ? DBUS_HANDLER_RESULT_HANDLED : DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
DBusHandlerResult message_handler(DBusConnection *connection, DBusMessage *message, void *user_data) { char *method = (char *)dbus_message_get_member(message); DBusMessage *reply = NULL; int clear_cache = 0, new_servers = 0; if (dbus_message_is_method_call(message, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) { /* string length: "%s" provides space for termination zero */ if (!introspection_xml && (introspection_xml = whine_malloc(strlen(introspection_xml_template) + strlen(daemon->dbus_name)))) sprintf(introspection_xml, introspection_xml_template, daemon->dbus_name); if (introspection_xml) { reply = dbus_message_new_method_return(message); dbus_message_append_args(reply, DBUS_TYPE_STRING, &introspection_xml, DBUS_TYPE_INVALID); } } else if (strcmp(method, "GetVersion") == 0) { char *v = VERSION; reply = dbus_message_new_method_return(message); dbus_message_append_args(reply, DBUS_TYPE_STRING, &v, DBUS_TYPE_INVALID); } else if (strcmp(method, "SetServers") == 0) { dbus_read_servers(message); new_servers = 1; } else if (strcmp(method, "SetServersEx") == 0) { reply = dbus_read_servers_ex(message, 0); new_servers = 1; } else if (strcmp(method, "SetDomainServers") == 0) { reply = dbus_read_servers_ex(message, 1); new_servers = 1; } else if (strcmp(method, "SetFilterWin2KOption") == 0) { reply = dbus_set_bool(message, OPT_FILTER, "filterwin2k"); } else if (strcmp(method, "SetBogusPrivOption") == 0) { reply = dbus_set_bool(message, OPT_BOGUSPRIV, "bogus-priv"); } else if (strcmp(method, "ClearCache") == 0) clear_cache = 1; else return (DBUS_HANDLER_RESULT_NOT_YET_HANDLED); if (new_servers) { my_syslog(LOG_INFO, _("setting upstream servers from DBus")); check_servers(); if (option_bool(OPT_RELOAD)) clear_cache = 1; } if (clear_cache) clear_cache_and_reload(dnsmasq_time()); method = user_data; /* no warning */ /* If no reply or no error, return nothing */ if (!reply) reply = dbus_message_new_method_return(message); if (reply) { dbus_connection_send (connection, reply, NULL); dbus_message_unref (reply); } return (DBUS_HANDLER_RESULT_HANDLED); }
static DBusHandlerResult handle_message(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct dbusif *dbusif = (struct dbusif *)user_data; struct tonegend *tonegend = dbusif->tonegend; DBusMessage *reply = NULL; uint32_t ser; int (*method)(DBusMessage *, struct tonegend *); const char *intf; const char *memb; const char *sig; gchar *key; const char *errname; char errdesc[256]; int success; (void)conn; if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_METHOD_CALL) TRACE("%s(): ignoring non method_call's", __FUNCTION__); else { intf = dbus_message_get_interface(msg); memb = dbus_message_get_member(msg); sig = dbus_message_get_signature(msg); ser = dbus_message_get_serial(msg); #if 0 TRACE("%s(): message no #%u received: '%s', '%s', '%s'", __FUNCTION__, ser, intf, memb, sig); #endif key = create_key((gchar *)memb, (gchar *)sig, (gchar *)intf); method = g_hash_table_lookup(dbusif->hash, key); g_free(key); success = method ? method(msg, tonegend) : FALSE; if (success) reply = dbus_message_new_method_return(msg); else { if (method) { errname = DBUS_ERROR_FAILED; snprintf(errdesc, sizeof(errdesc), "Internal error"); } else { errname = DBUS_ERROR_NOT_SUPPORTED; snprintf(errdesc, sizeof(errdesc), "Method '%s(%s)' " "not supported", memb, sig); } reply = dbus_message_new_error(msg, errname, errdesc); } dbus_message_set_reply_serial(msg, ser); if (!dbus_connection_send(dbusif->conn, reply, NULL)) LOG_ERROR("%s(): D-Bus message reply failure", __FUNCTION__); #if 0 else TRACE("%s(): message no #%u replied", __FUNCTION__, ser); #endif dbus_message_unref(reply); } return DBUS_HANDLER_RESULT_HANDLED; }