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