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