//! Returns DBus message path, used in scripts static PyObject * c_bus_path(PyObject *self, PyObject *args) { const char *path = dbus_message_get_path(my_proc.bus_msg); PyObject *py_str = PyString_FromString(path); Py_INCREF(py_str); return py_str; }
/** * @brief Optionally prints a trace of a D-Bus message depending on the "level". * * @param [in] level Trace mask controlling whether trace appears. * @param [in] msg The D-Bus message to trace. */ void l2dbus_traceMessage ( unsigned level, struct DBusMessage* msg ) { const cdbus_Char* msgTypeStr ="UNKNOWN"; cdbus_Int32 msgType = DBUS_MESSAGE_TYPE_INVALID; const cdbus_Char* path = NULL; const cdbus_Char* intf = NULL; const cdbus_Char* name = NULL; const cdbus_Char* dest = NULL; const cdbus_Char* errName = NULL; if ( NULL != msg ) { msgType = dbus_message_get_type(msg); msgTypeStr = dbus_message_type_to_string(msgType); if ( (DBUS_MESSAGE_TYPE_METHOD_CALL == msgType) || (DBUS_MESSAGE_TYPE_SIGNAL == msgType) ) { path = dbus_message_get_path(msg); intf = dbus_message_get_interface(msg); name = dbus_message_get_member(msg); l2dbus_trace(level, "(Ser=%u) [%s] <%s> %s%s%s", dbus_message_get_serial(msg), msgTypeStr, path ? path : "", intf ? intf : "", intf ? "." : "", name ? name : ""); } else if (DBUS_MESSAGE_TYPE_METHOD_RETURN == msgType) { dest = dbus_message_get_destination(msg); l2dbus_trace(level, "(RSer=%u) [%s] -> %s", dbus_message_get_reply_serial(msg), msgTypeStr, dest ? dest : ""); } else if (DBUS_MESSAGE_TYPE_ERROR == msgType ) { errName = dbus_message_get_error_name(msg); l2dbus_trace(level, "(RSer=%u) [%s] %s", dbus_message_get_reply_serial(msg), msgTypeStr, errName ? errName : ""); } else { l2dbus_trace(level, "(Ser=%u) [%s]", dbus_message_get_serial(msg), msgTypeStr); } } }
/* main() */ int main(int argc, char *argv[]) { DBusConnection *conn = NULL; DBusMessage *msg_query = NULL; DBusMessage *msg_reply = NULL; DBusError error; const char *xml_data = NULL; int return_code; /* Initialize the error state. */ dbus_error_init(&error); /* Connect to user-session D-Bus */ fprintf(stdout, "Connecting to Session D-Bus\n"); conn = dbus_bus_get(DBUS_BUS_SESSION, &error); exit_on_error("Failed to open user-session bus.\n", &error); /* Print unique name */ fprintf(stdout, "D-Bus unique name: %s\n", \ dbus_bus_get_unique_name(conn)); /* Request well-know name on the session bus */ return_code = dbus_bus_request_name(conn, DBUS_CLIENT_NAME, \ DBUS_NAME_FLAG_REPLACE_EXISTING, \ &error); exit_on_error("Failed to get well-known name.", &error); if (DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != return_code) exit(EXIT_FAILURE); /* Send "Introspect" message */ msg_query = dbus_message_new_method_call(DBUS_SERVER_NAME, /* Target */ DBUS_OBJECT_PATH, /* Object */ DBUS_IFACE_INTRO, /* Interface */ "Introspect"); /* Method name */ msg_reply = dbus_connection_send_with_reply_and_block(conn, msg_query, 1000, &error); exit_on_error("Failed to send Introspect message.", &error); /* Get the string argument from Introspect call */ dbus_message_get_args(msg_reply, &error, DBUS_TYPE_STRING, \ &xml_data, DBUS_TYPE_INVALID); /* Print message information */ fprintf(stdout, "Object Path \t= %s\n", dbus_message_get_path(msg_query)); fprintf(stdout, "Interface \t= %s\n", dbus_message_get_interface(msg_query)); fprintf(stdout, "Message \t= %s\n", dbus_message_get_member(msg_query)); fprintf(stdout, "Introspect xml_data:\n%s\n", xml_data); /* Free messages */ dbus_message_unref(msg_query); dbus_message_unref(msg_reply); /* Free the connection. */ dbus_connection_unref(conn); return EXIT_SUCCESS; }
/* * On success @param msg is unref'd or its ref is stolen by the returned * Eldbus_Pending. */ Eldbus_Pending * _eldbus_connection_send(Eldbus_Connection *conn, Eldbus_Message *msg, Eldbus_Message_Cb cb, const void *cb_data, double timeout) { Eldbus_Pending *pending; Eldbus_Message *error_msg; DBG("conn=%p, msg=%p, cb=%p, cb_data=%p, timeout=%f", conn, msg, cb, cb_data, timeout); if (!cb) { dbus_connection_send(conn->dbus_conn, msg->dbus_msg, NULL); eldbus_message_unref(msg); return NULL; } pending = calloc(1, sizeof(Eldbus_Pending)); EINA_SAFETY_ON_NULL_RETURN_VAL(pending, NULL); pending->cb = cb; pending->cb_data = cb_data; pending->conn = conn; pending->dest = eina_stringshare_add(dbus_message_get_destination(msg->dbus_msg)); pending->interface = eina_stringshare_add(dbus_message_get_interface(msg->dbus_msg)); pending->method = eina_stringshare_add(dbus_message_get_member(msg->dbus_msg)); pending->path = eina_stringshare_add(dbus_message_get_path(msg->dbus_msg)); /* Steal the reference */ pending->msg_sent = msg; EINA_MAGIC_SET(pending, ELDBUS_PENDING_MAGIC); if (!dbus_connection_send_with_reply(conn->dbus_conn, msg->dbus_msg, &pending->dbus_pending, timeout)) { error_msg = _eldbus_message_error_get(msg, "org.enlightenment.DBus.NoConnection", "Eldbus_Connection was closed."); eldbus_pending_dispatch(pending, error_msg); return NULL; } if (!pending->dbus_pending) { error_msg = _eldbus_message_error_get(msg, "org.enlightenment.DBus.Error", "dbus_pending is NULL."); eldbus_pending_dispatch(pending, error_msg); return NULL; } if (dbus_pending_call_set_notify(pending->dbus_pending, cb_pending, pending, NULL)) return pending; dbus_pending_call_cancel(pending->dbus_pending); error_msg = _eldbus_message_error_get(pending->msg_sent, "org.enlightenment.DBus.Error", "Error when try set callback to message."); eldbus_pending_dispatch(pending, error_msg); return NULL; }
void cDBusMessagePlugin::SVDRPCommand(void) { const char *pluginName = dbus_message_get_path(_msg); const char *command = NULL; const char *option = NULL; DBusMessageIter args; if (!dbus_message_iter_init(_msg, &args)) esyslog("dbus2vdr: %s.SVDRPCommand: message misses an argument for the command", DBUS_VDR_PLUGIN_INTERFACE); else { int rc = cDBusHelper::GetNextArg(args, DBUS_TYPE_STRING, &command); if (rc < 0) esyslog("dbus2vdr: %s.SVDRPCommand: 'command' argument is not a string", DBUS_VDR_PLUGIN_INTERFACE); else if (rc == 0) isyslog("dbus2vdr: %s.SVDRPCommand: command '%s' has no option", DBUS_VDR_PLUGIN_INTERFACE, command); else if (cDBusHelper::GetNextArg(args, DBUS_TYPE_STRING, &option) < 0) esyslog("dbus2vdr: %s.SVDRPCommand: 'option' argument is not string", DBUS_VDR_PLUGIN_INTERFACE); } dbus_int32_t replyCode = 500; cString replyMessage; if ((pluginName != NULL) && (command != NULL)) { if ((strlen(pluginName) > 9) && (strncmp(pluginName, "/Plugins/", 9) == 0)) { cPlugin *plugin = cPluginManager::GetPlugin(pluginName + 9); if (plugin != NULL) { if (option == NULL) option = ""; isyslog("dbus2vdr: invoking %s.SVDRPCommand(\"%s\", \"%s\")", plugin->Name(), command, option); replyCode = 900; cString s = plugin->SVDRPCommand(command, option, replyCode); if (*s) { replyMessage = s; } else { replyCode = 500; replyMessage = cString::sprintf("Command unrecognized: \"%s\"", command); } } } } DBusMessage *reply = dbus_message_new_method_return(_msg); dbus_message_iter_init_append(reply, &args); if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT32, &replyCode)) esyslog("dbus2vdr: %s.SVDRPCommand: out of memory while appending the reply-code", DBUS_VDR_PLUGIN_INTERFACE); if (*replyMessage == NULL) replyMessage = ""; const char *message = *replyMessage; if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING, &message)) esyslog("dbus2vdr: %s.SVDRPCommand: out of memory while appending the reply-message", DBUS_VDR_PLUGIN_INTERFACE); dbus_uint32_t serial = 0; if (!dbus_connection_send(_conn, reply, &serial)) esyslog("dbus2vdr: %s.SVDRPCommand: out of memory while sending the reply", DBUS_VDR_PLUGIN_INTERFACE); dbus_message_unref(reply); }
const char* dsme_dbus_message_path(const DsmeDbusMessage* msg) { if (msg && msg->msg) { const char* path = dbus_message_get_path(msg->msg); if (path) return path; } return ""; }
DBusHandlerResult avahi_dbus_msg_record_browser_impl(DBusConnection *c, DBusMessage *m, void *userdata) { DBusError error; RecordBrowserInfo *i = userdata; assert(c); assert(m); assert(i); dbus_error_init(&error); avahi_log_debug(__FILE__": interface=%s, path=%s, member=%s", dbus_message_get_interface(m), dbus_message_get_path(m), dbus_message_get_member(m)); /* Introspection */ if (dbus_message_is_method_call(m, DBUS_INTERFACE_INTROSPECTABLE, "Introspect")) return avahi_dbus_handle_introspect(c, m, "org.freedesktop.Avahi.RecordBrowser.xml"); /* Access control */ if (strcmp(dbus_message_get_sender(m), i->client->name)) return avahi_dbus_respond_error(c, m, AVAHI_ERR_ACCESS_DENIED, NULL); if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_RECORD_BROWSER, "Free")) { if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { avahi_log_warn("Error parsing RecordBrowser::Free message"); goto fail; } avahi_dbus_record_browser_free(i); return avahi_dbus_respond_ok(c, m); } if (dbus_message_is_method_call(m, AVAHI_DBUS_INTERFACE_RECORD_BROWSER, "Start")) { if (!dbus_message_get_args(m, &error, DBUS_TYPE_INVALID)) { avahi_log_warn("Error parsing RecordBrowser::Start message"); goto fail; } avahi_dbus_record_browser_start(i); return avahi_dbus_respond_ok(c, m); } avahi_log_warn("Missed message %s::%s()", dbus_message_get_interface(m), dbus_message_get_member(m)); fail: if (dbus_error_is_set(&error)) dbus_error_free(&error); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
DBusHandlerResult a2dp_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.AudioSink", "PropertyChanged")) { jobjectArray str_array = parse_property_change(env, msg, (Properties *)&sink_properties, sizeof(sink_properties) / sizeof(Properties)); const char *c_path = dbus_message_get_path(msg); jstring path = env->NewStringUTF(c_path); env->CallVoidMethod(nat->me, method_onSinkPropertyChanged, path, str_array); env->DeleteLocalRef(path); 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; }
static int ldbus_message_get_path(lua_State *L) { DBusMessage *message = check_DBusMessage(L, 1); const char * object_path = dbus_message_get_path(message); if (object_path == NULL) { lua_pushnil(L); } else { lua_pushstring(L, object_path); } return 1; }
/** * message_handler - Handles incoming DBus messages * @connection: DBus connection on which message was received * @message: Received message * @user_data: pointer to description of object to which message was sent * Returns: Returns information whether message was handled or not * * Reads message interface and method name, then checks if they matches one * of the special cases i.e. introspection call or properties get/getall/set * methods and handles it. Else it iterates over registered methods list * and tries to match method's name and interface to those read from message * If appropriate method was found its handler function is called and * response is sent. Otherwise, the DBUS_ERROR_UNKNOWN_METHOD error message * will be sent. */ static DBusHandlerResult message_handler(DBusConnection *connection, DBusMessage *message, void *user_data) { struct wpa_dbus_object_desc *obj_dsc = user_data; const char *method; const char *path; const char *msg_interface; DBusMessage *reply; /* get method, interface and path the message is addressed to */ method = dbus_message_get_member(message); path = dbus_message_get_path(message); msg_interface = dbus_message_get_interface(message); if (!method || !path || !msg_interface) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; wpa_printf(MSG_MSGDUMP, "dbus: %s.%s (%s)", msg_interface, method, path); /* if message is introspection method call */ if (!os_strncmp(WPA_DBUS_INTROSPECTION_METHOD, method, WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) && !os_strncmp(WPA_DBUS_INTROSPECTION_INTERFACE, msg_interface, WPAS_DBUS_INTERFACE_MAX)) { #ifdef CONFIG_CTRL_IFACE_DBUS_INTRO reply = wpa_dbus_introspect(message, obj_dsc); #else /* CONFIG_CTRL_IFACE_DBUS_INTRO */ reply = dbus_message_new_error( message, DBUS_ERROR_UNKNOWN_METHOD, "wpa_supplicant was compiled without " "introspection support."); #endif /* CONFIG_CTRL_IFACE_DBUS_INTRO */ } else if (!os_strncmp(WPA_DBUS_PROPERTIES_INTERFACE, msg_interface, WPAS_DBUS_INTERFACE_MAX)) { /* if message is properties method call */ reply = properties_handler(message, obj_dsc); } else { reply = msg_method_handler(message, obj_dsc); } /* If handler succeed returning NULL, reply empty message */ if (!reply) reply = dbus_message_new_method_return(message); if (reply) { if (!dbus_message_get_no_reply(message)) dbus_connection_send(connection, reply, NULL); dbus_message_unref(reply); } wpa_dbus_flush_all_changed_properties(connection); return DBUS_HANDLER_RESULT_HANDLED; }
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; }
void print_message (DBusMessage *message, dbus_bool_t literal) { DBusMessageIter iter; const char *sender; const char *destination; int message_type; message_type = dbus_message_get_type (message); sender = dbus_message_get_sender (message); destination = dbus_message_get_destination (message); if (!literal) { printf ("%s sender=%s -> dest=%s", type_to_name (message_type), sender ? sender : "(null sender)", destination ? destination : "(null destination)"); switch (message_type) { case DBUS_MESSAGE_TYPE_METHOD_CALL: case DBUS_MESSAGE_TYPE_SIGNAL: printf (" serial=%u path=%s; interface=%s; member=%s\n", dbus_message_get_serial (message), dbus_message_get_path (message), dbus_message_get_interface (message), dbus_message_get_member (message)); break; case DBUS_MESSAGE_TYPE_METHOD_RETURN: printf (" reply_serial=%u\n", dbus_message_get_reply_serial (message)); break; case DBUS_MESSAGE_TYPE_ERROR: printf (" error_name=%s reply_serial=%u\n", dbus_message_get_error_name (message), dbus_message_get_reply_serial (message)); break; default: printf ("\n"); break; } } dbus_message_iter_init (message, &iter); print_iter (&iter, literal, 1); fflush (stdout); }
//! CSL method: script() static PyObject * c_script(PyObject *self, PyObject *args) { /*! * This method can be used in CSL scripts to get script's owner. * * @return Owner of the running CSL script. */ const char *path = dbus_message_get_path(my_proc.bus_msg); const char *app = strsub(path, strlen("/package/"), 0); return PyString_FromString(app); }
static DBusHandlerResult task_filter(DBusConnection *conn, DBusMessage *message, void *user_data) { struct connman_task *task; struct notify_data *notify; const char *path, *member; DBusMessage *reply = NULL; if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_METHOD_CALL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (dbus_message_has_interface(message, CONNMAN_TASK_INTERFACE) == FALSE) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; path = dbus_message_get_path(message); if (path == NULL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; task = g_hash_table_lookup(task_hash, path); if (task == NULL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; member = dbus_message_get_member(message); if (member == NULL) goto send_reply; notify = g_hash_table_lookup(task->notify, member); if (notify == NULL) goto send_reply; if (notify->func) reply = notify->func(task, message, notify->data); send_reply: if (dbus_message_get_no_reply(message) == FALSE && reply == NULL) { reply = dbus_message_new_method_return(message); if (reply == NULL) return DBUS_HANDLER_RESULT_NEED_MEMORY; } if (reply != NULL) { dbus_connection_send(conn, reply, NULL); dbus_message_unref(reply); } return DBUS_HANDLER_RESULT_HANDLED; }
static DBusHandlerResult method_call_handler(lua_State *S, DBusMessage *msg) { lua_State *T; struct message_object *m; const char *path = dbus_message_get_path(msg); const char *interface = dbus_message_get_interface(msg); const char *member = dbus_message_get_member(msg); lem_debug("received call\n %s\n %s\n %s(%s)", path, interface, member, dbus_message_get_signature(msg)); lua_pushstring(S, path ? path : ""); lua_rawget(S, LEM_DBUS_OBJECT_TABLE); if (lua_type(S, -1) != LUA_TTABLE) { lua_settop(S, LEM_DBUS_TOP); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } lua_pushfstring(S, "%s.%s", interface ? interface : "", member ? member : ""); lua_rawget(S, -2); if (lua_type(S, -1) != LUA_TFUNCTION) { lua_settop(S, LEM_DBUS_TOP); return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } /* create new thread */ T = lem_newthread(); lua_pushvalue(S, LEM_DBUS_BUS_OBJECT); lua_xmove(S, T, 2); lua_settop(S, LEM_DBUS_TOP); /* push the send_reply function */ m = lua_newuserdata(T, sizeof(struct message_object)); m->msg = msg; dbus_message_ref(msg); /* set metatable */ lua_pushvalue(S, LEM_DBUS_MESSAGE_META); lua_xmove(S, T, 1); lua_setmetatable(T, -2); lua_pushcclosure(T, message_reply, 2); lem_queue(T, lem_dbus_push_arguments(T, msg) + 1); return DBUS_HANDLER_RESULT_HANDLED; }
/* * Wickedd is sending us a signal indicating internal device state change. * We want to wait for this signal and when it is >= device-up return TRUE. * After timeout we fail... */ void ni_state_change_signal_handler(ni_dbus_connection_t *conn, ni_dbus_message_t *msg, void *user_data) { const char *signal_name = dbus_message_get_member(msg); const char *object_path = dbus_message_get_path(msg); ni_dbus_variant_t argv = NI_DBUS_VARIANT_INIT; ni_ifworker_array_t *ifworkers = user_data; ni_fsm_state_t cur_state, target_state; const char *ifname; unsigned int i; if (ni_string_empty(object_path)) return; /* Deserialize dbus message */ if (ni_dbus_message_get_args_variants(msg, &argv, 1) < 0 || !ni_dbus_variant_is_dict(&argv)) { ni_error("Unable to retrieve dict from signal %s, object_path=%s", signal_name, object_path); return; } if (!ni_dbus_dict_get_uint32(&argv, "current-state", &cur_state) || !ni_dbus_dict_get_uint32(&argv, "target-state", &target_state) || !ni_dbus_dict_get_string(&argv, "ifname", &ifname)) { ni_error("Unable to retrieve dict's values from signal %s, object_path=%s", signal_name, object_path); return; } ni_debug_application("received signal %s; object_path=%s; target_state=%s, state_name=%s", signal_name, object_path, ni_ifworker_state_name(target_state), ni_ifworker_state_name(cur_state)); for (i = 0; i < ifworkers->count; ++i) { ni_ifworker_t *w = ifworkers->data[i]; if (cur_state != NI_FSM_STATE_NONE && cur_state != target_state) continue; if (!ni_string_eq(w->name, ifname)) continue; ni_warn("%s: Device %s", ifname, cur_state == target_state ? "succeeded" : "failed"); ni_ifworker_array_remove_with_children(ifworkers, w); } ni_dbus_variant_destroy(&argv); }
static DBusMessage * properties_get_or_set(DBusMessage *message, DBusMessageIter *iter, char *interface, struct wpa_dbus_object_desc *obj_dsc) { const struct wpa_dbus_property_desc *property_dsc; char *property; const char *method; method = dbus_message_get_member(message); property_dsc = obj_dsc->properties; /* Second argument: property name (DBUS_TYPE_STRING) */ if (!dbus_message_iter_next(iter) || 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, &property); while (property_dsc && property_dsc->dbus_property) { /* compare property names and * interfaces */ if (!os_strncmp(property_dsc->dbus_property, property, WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) && !os_strncmp(property_dsc->dbus_interface, interface, WPAS_DBUS_INTERFACE_MAX)) break; property_dsc++; } if (property_dsc == NULL || property_dsc->dbus_property == NULL) { wpa_printf(MSG_DEBUG, "no property handler for %s.%s on %s", interface, property, dbus_message_get_path(message)); return dbus_message_new_error(message, DBUS_ERROR_INVALID_ARGS, "No such property"); } if (os_strncmp(WPA_DBUS_PROPERTIES_GET, method, WPAS_DBUS_METHOD_SIGNAL_PROP_MAX) == 0) { wpa_printf(MSG_MSGDUMP, "%s: Get(%s)", __func__, property); return properties_get(message, property_dsc, obj_dsc->user_data); } wpa_printf(MSG_MSGDUMP, "%s: Set(%s)", __func__, property); return properties_set(message, property_dsc, obj_dsc->user_data); }
static void * object_get_from_message(DBusMessage *message, char *type) { const char *opath=dbus_message_get_path(message); char *prefix; void *ret=NULL; prefix=g_strdup_printf("%s/%s/", object_path, type); if (!strncmp(prefix, opath, strlen(prefix))) ret=object_get(opath); else dbg(0,"wrong object type\n"); g_free(prefix); return ret; }
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; }
static DBusMessage *cancel_request(DBusConnection *conn, DBusMessage *msg, void *user_data) { const char *path; g_print("Request canceled\n"); path = dbus_message_get_path(msg); g_print(" from %s\n", path); remove_source(path); return dbus_message_new_method_return(msg); }
//! Returns package name, used in scripts static PyObject * c_package(PyObject *self, PyObject *args) { const char *path = dbus_message_get_path(my_proc.bus_msg); if (strncmp(path, "/package/", strlen("/package/")) == 0) { const char *app = strsub(path, strlen("/package/"), strlen(path)); if (strlen(app) > 0) { return PyString_FromString(app); } } Py_INCREF(Py_None); return Py_None; }
static DBusHandlerResult bsd_dbus_message_handler (DBusConnection *connection, DBusMessage *message, void *user_data){ DBusMessage *reply = NULL; if(message == NULL) return DBUS_HANDLER_RESULT_HANDLED; if (strcmp(dbus_message_get_path(message),BSD_DBUS_OBJPATH) == 0) { if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_COPY_FILES_BETEWEEN_BORADS)) { reply = bsd_copy_files_between_boards(connection,message,user_data); } else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_SYNCHRONIZE_FILES_TO_OTHER_BOARDS)) { reply = bsd_synchronize_files(connection,message,user_data); } else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_SYNCHRONIZE_FILES_TO_OTHER_BOARDS_V2)) { reply = bsd_synchronize_files_v2(connection,message,user_data); } else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_GET_ALIVE_SLOT_IDS)) { reply = bsd_get_alive_slot_ids(connection,message,user_data); } else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_SET_BSD_DAEMONLOG_LEVEL)) { reply = bsd_set_daemonlog_level(connection,message,user_data); } else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_COPY_FILES_BETEWEEN_DEVICES)) { reply = bsd_copy_files_between_devices(connection,message,user_data); } else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_CHECK_DETINATION_BOARD_INFORMATION)) { reply = bsd_check_destination_board(connection,message,user_data); } else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_CHECK_DETINATION_DEVICE_INFORMATION)) { reply = bsd_check_destination_device(connection,message,user_data); } else if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_CLOSE_TCP_SOCKET)) { reply = bsd_close_tcp_socket(connection,message,user_data); } if (dbus_message_is_method_call(message,BSD_DBUS_INTERFACE,BSD_COPY_FILES_BETEWEEN_BORADS_V2)) { reply = bsd_copy_files_between_boards_v2(connection,message,user_data); } } if (reply) { dbus_connection_send (connection, reply, NULL); dbus_connection_flush(connection); dbus_message_unref (reply); } return DBUS_HANDLER_RESULT_HANDLED ; }
/* To support the BOT */ static DBusHandlerResult __obex_authorize_event_filter(DBusConnection *sys_conn, DBusMessage *msg, void *data) { DBG("+"); char *member; const char *path = dbus_message_get_path(msg); const char *addr = NULL; const char *name = NULL; bluetooth_device_address_t device_addr = { {0} }; int event; if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (path == NULL || strcmp(path, "/") == 0) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; member = (char *)dbus_message_get_member(msg); DBG("member (%s)\n", member); if (dbus_message_is_signal(msg, BT_AGENT_INTERFACE, BT_AGENT_SIGNAL_OBEX_AUTHORIZE)) { dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &addr, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID); DBG("Obex Authorize request [%s], [%s]", addr, name); if (addr == NULL) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; event = BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE; _bluetooth_internal_convert_addr_string_to_addr_type( &device_addr, addr); _bluetooth_internal_event_cb(event, BLUETOOTH_ERROR_NONE, &device_addr); } else { return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } DBG("-"); return DBUS_HANDLER_RESULT_HANDLED; }
static DBusHandlerResult dbus_message_handler(DBusConnection *connection, DBusMessage *message, void *user_data) { const char *method; const char *path; dbus_bool_t handled = TRUE; method = dbus_message_get_member(message); path = dbus_message_get_path(message); wpa_printf(MSG_ERROR, "dbus_message_handler() got method %s for path " "%s", method, path); return handled ? DBUS_HANDLER_RESULT_HANDLED : DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
/** * wpas_message_handler - dispatch incoming dbus messages * @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 to the correct * handlers, depending on what the message's target object path is, * and what the method call is. */ static DBusHandlerResult wpas_message_handler(DBusConnection *connection, DBusMessage *message, void *user_data) { struct wpas_dbus_priv *ctrl_iface = user_data; const char *method; const char *path; const char *msg_interface; DBusMessage *reply = NULL; method = dbus_message_get_member(message); path = dbus_message_get_path(message); msg_interface = dbus_message_get_interface(message); if (!method || !path || !ctrl_iface || !msg_interface) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; /* Validate the method interface */ if (strcmp(msg_interface, WPAS_DBUS_INTERFACE) != 0) return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; if (!strcmp(path, WPAS_DBUS_PATH)) { /* dispatch methods against our global dbus interface here */ if (!strcmp(method, "addInterface")) { reply = wpas_dbus_global_add_interface( message, ctrl_iface->global); } else if (!strcmp(method, "removeInterface")) { reply = wpas_dbus_global_remove_interface( message, ctrl_iface->global); } else if (!strcmp(method, "getInterface")) { reply = wpas_dbus_global_get_interface( message, ctrl_iface->global); } else if (!strcmp(method, "setDebugParams")) { reply = wpas_dbus_global_set_debugparams( message, ctrl_iface->global); } } /* 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); } return reply ? DBUS_HANDLER_RESULT_HANDLED : DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
DBusHandlerResult cspi_dbus_handle_deviceEvent (DBusConnection *bus, DBusMessage *message, void *data) { const char *path = dbus_message_get_path (message); int id; Accessibility_DeviceEvent event; CSpiDeviceListener *listener; DBusMessageIter iter; CSpiDeviceListenerClass *klass; dbus_bool_t retval = FALSE; GList *l; DBusMessage *reply; void *p = &event; if (sscanf (path, "/org/freedesktop/atspi/listeners/%d", &id) != 1) { g_warning ("Bad listener path: %s\n", path); goto done; } for (l = device_listeners; l; l = g_list_next (l)) { listener = l->data; if (listener->id == id) break; } if (!l) { goto done; } dbus_message_iter_init (message, &iter); dbind_any_demarshal (&iter, (char **) &deviceEvent_type, &p); klass = CSPI_DEVICE_LISTENER_GET_CLASS (listener); if (klass->device_event) { retval = (*klass->device_event) (listener, &event); } done: reply = dbus_message_new_method_return (message); if (reply) { dbus_message_append_args (reply, DBUS_TYPE_BOOLEAN, &retval, DBUS_TYPE_INVALID); dbus_connection_send (SPI_bus(), reply, NULL); dbus_message_unref (reply); } return DBUS_HANDLER_RESULT_HANDLED; }
static DBusHandlerResult filter_func(DBusConnection *conn, DBusMessage *bus_msg, void *data) { const char *method = dbus_message_get_member(bus_msg); const char *iface = dbus_message_get_interface(bus_msg); const char *sender = dbus_message_get_sender(bus_msg); const char *path = dbus_message_get_path(bus_msg); PyObject *py_args = pydbus_import(bus_msg); if (!dbus_message_has_destination(bus_msg, config_unique_address) && strncmp(dbus_message_get_destination(bus_msg), DBUS_SERVICE_NAME, strlen(DBUS_SERVICE_NAME))) { return DBUS_HANDLER_RESULT_HANDLED; } switch (dbus_message_get_type(bus_msg)) { case DBUS_MESSAGE_TYPE_METHOD_CALL: if (my_proc.nr_children > MAX_PROC) { // Busy return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } else { log_debug("Got message '%s.%s' from '%s'\n", iface, method, sender); if (strcmp(config_interface, iface) == 0 && strcmp(path, "/") == 0) { // "setLocale" and "cancel" methods are handled in main process if (strcmp(method, "setLocale") == 0 || strcmp(method, "cancel") == 0 || strcmp(method, "listRunning") == 0) { handle_core_message(bus_msg, path, iface, method, sender, py_args); } else { // Else, handle in child process proc_fork(handle_message, bus_msg); } } else { // Else, handle in child process proc_fork(handle_message, bus_msg); } break; } case DBUS_MESSAGE_TYPE_SIGNAL: log_debug("Got signal '%s.%s' from '%s'\n", iface, method, sender); break; } return DBUS_HANDLER_RESULT_HANDLED; }
DBusHandlerResult database_adaptor::handle_message(DBusConnection* connection, DBusMessage* message) { clog << __FUNCTION__ << endl; assert(dbus_message_has_interface(message, INTERFACE_NAME)); auto dst = dbus_message_get_path(message); if (dst == nullptr || strlen(dst) == 0) { cerr << "Unknown message destination" << endl; return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } auto obj = m_objects.find(dst); if (obj == m_objects.end()) { cerr << "Destination object " << dst << " not found" << endl; return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } auto name = dbus_message_get_member(message); if (name == nullptr || strlen(name) == 0) { cerr << "Unknown method name " << endl; return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } typedef dboost::dbus_ptr<DBusMessage> (database_adaptor::*caller)(database*, DBusMessage*); typedef map<string, caller> caller_table; static const caller_table vtbl { { "add_person", &database_adaptor::call_add_person }, { "find_person_by_id", &database_adaptor::call_find_person_by_id }, { "find_by_family", &database_adaptor::call_find_by_family } }; auto func = vtbl.find(name); if (func == vtbl.end()) { cerr << "Wrong method name " << name << endl; return DBUS_HANDLER_RESULT_HANDLED; } auto result = (this->*func->second)(obj->second, message); clog << "Reply result" << endl; dbus_connection_send(connection, result.get(), 0); return DBUS_HANDLER_RESULT_HANDLED; }
static DBusHandlerResult gsm_consolekit_dbus_filter (DBusConnection *connection, DBusMessage *message, void *user_data) { GsmConsolekit *manager; manager = GSM_CONSOLEKIT (user_data); if (dbus_message_is_signal (message, DBUS_INTERFACE_LOCAL, "Disconnected") && strcmp (dbus_message_get_path (message), DBUS_PATH_LOCAL) == 0) { gsm_consolekit_free_dbus (manager); return DBUS_HANDLER_RESULT_HANDLED; } return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; }
static DBusHandlerResult filter_func(DBusConnection *connection, DBusMessage *message, void *user_data) { printf("filter_func: path=%s, interface=%s, member=%s\n", dbus_message_get_path(message), dbus_message_get_interface(message), dbus_message_get_member(message)); if (dbus_message_is_signal (message, DBUS_PMD_INTERFACE, DBUS_DEFAULT_METHOD)) { _dbus_verbose("%s: dbus_message_is_signal disconnected!!!\n", __FILE__); return DBUS_HANDLER_RESULT_HANDLED; } else { return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; } }