static DBusHandlerResult
default_message_filter
( DBusConnection *connection,
DBusMessage *message,
void *p
)
{
DBusConnectionState *cs = p;
uint32_t type =dbus_message_get_type( message ),
serial =dbus_message_get_serial( message );
uint8_t reply =dbus_message_get_no_reply( message )==0;
const char
*path = dbus_message_get_path( message ),
*dest = dbus_message_get_destination( message ),
*member = dbus_message_get_member( message ),
*interface=dbus_message_get_interface( message ),
*sender =dbus_message_get_sender( message ),
*signature=dbus_message_get_signature( message );
connection = connection;
if(cs->mf)
return
(*(cs->mf))( cs, type, reply, serial, dest, path, member, interface, 0L,
sender, signature, message, 0L, 0L, 0L, cs->def_mf_obj
) ;
return HANDLED;
}
/** Helper for sending boolean replies to dbus method calls
*
* Reply will not be sent if no_reply attribute is set
* in the method call message.
*
* @param msg method call message to reply
* @param value integer number to send
*
* @return TRUE on success, or FALSE if reply could not be sent
*/
static
gboolean
cpu_keepalive_reply_int(DBusMessage *const msg, gint value)
{
gboolean success = TRUE;
if( !dbus_message_get_no_reply(msg) )
{
dbus_int32_t data = value;
DBusMessage *reply = dbus_new_method_reply(msg);
dbus_message_append_args(reply,
DBUS_TYPE_INT32, &data,
DBUS_TYPE_INVALID);
/* dbus_send_message() unrefs the message */
success = dbus_send_message(reply), reply = 0;
if( !success )
{
mce_log(LL_WARN, "failed to send reply to %s",
dbus_message_get_member(msg));
}
}
return success;
}
/** D-Bus callback for the get color profile ids method call
*
* @param msg The D-Bus message
* @return TRUE
*/
static gboolean color_profile_ids_get_req_dbus_cb(DBusMessage *const msg)
{
mce_log(LL_DEVEL, "Received list color profiles request from %s",
mce_dbus_get_message_sender_ident(msg));
DBusMessage *rsp = 0;
int cnt = sizeof color_profiles / sizeof *color_profiles;
const char * const * vec = color_profiles;
if( dbus_message_get_no_reply(msg) )
goto EXIT;
if( !(rsp = dbus_message_new_method_return(msg)) )
goto EXIT;
if( !dbus_message_append_args(rsp,
DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING, &vec, cnt,
DBUS_TYPE_INVALID) )
goto EXIT;
dbus_send_message(rsp), rsp = 0;
EXIT:
if( rsp ) dbus_message_unref(rsp);
return TRUE;
}
/** Helper for sending boolean replies to dbus method calls
*
* Reply will not be sent if no_reply attribute is set
* in the method call message.
*
* @param msg method call message to reply
* @param value TRUE/FALSE to send
*
* @return TRUE on success, or FALSE if reply could not be sent
*/
static
gboolean
cka_dbusutil_reply_bool(DBusMessage *const msg, gboolean value)
{
gboolean success = TRUE;
if( !dbus_message_get_no_reply(msg) )
{
dbus_bool_t data = value;
DBusMessage *reply = dbus_new_method_reply(msg);
dbus_message_append_args(reply,
DBUS_TYPE_BOOLEAN, &data,
DBUS_TYPE_INVALID);
/* dbus_send_message() unrefs the message */
success = dbus_send_message(reply), reply = 0;
if( !success )
{
mce_log(LL_WARN, "failed to send reply to %s",
dbus_message_get_member(msg));
}
}
return success;
}
static DBusMessage *l2tp_get_sec(struct connman_task *task,
DBusMessage *msg, void *user_data)
{
const char *user, *passwd;
struct connman_provider *provider = user_data;
if (dbus_message_get_no_reply(msg) == FALSE) {
DBusMessage *reply;
user = connman_provider_get_string(provider, "L2TP.User");
passwd = connman_provider_get_string(provider, "L2TP.Password");
if (user == NULL || strlen(user) == 0 ||
passwd == NULL || strlen(passwd) == 0)
return NULL;
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_append_args(reply, DBUS_TYPE_STRING, &user,
DBUS_TYPE_STRING, &passwd,
DBUS_TYPE_INVALID);
return reply;
}
return NULL;
}
/**
* D-Bus callback for the remove activity callback method call
*
* @param msg The D-Bus message
* @return TRUE on success, FALSE on failure
*/
static gboolean remove_activity_callback_dbus_cb(DBusMessage *const msg)
{
dbus_bool_t no_reply = dbus_message_get_no_reply(msg);
const gchar *sender = dbus_message_get_sender(msg);
gboolean status = FALSE;
if (sender == NULL) {
mce_log(LL_ERR,
"Received invalid remove activity callback request "
"(sender == NULL)");
goto EXIT;
}
mce_log(LL_DEVEL, "Received remove activity callback request from %s",
mce_dbus_get_name_owner_ident(sender));
status = TRUE;
remove_activity_cb(sender);
EXIT:
if (no_reply == FALSE) {
DBusMessage *reply = dbus_new_method_reply(msg);
status = dbus_send_message(reply);
} else {
status = TRUE;
}
return status;
}
static int ldbus_message_get_no_reply(lua_State *L) {
DBusMessage *message = check_DBusMessage(L, 1);
lua_pushboolean(L, dbus_message_get_no_reply(message));
return 1;
}
/**
* D-Bus callback for the ALS disabling method call
*
* @param msg The D-Bus message
* @return TRUE
*/
static gboolean als_disable_req_dbus_cb(DBusMessage *const msg)
{
const char *sender;
gssize retval;
if( !(sender = dbus_message_get_sender(msg)) )
goto EXIT;
mce_log(LL_DEBUG, "Received ALS disable request from %s", sender);
retval = mce_dbus_owner_monitor_remove(sender,
&ext_als_enablers);
if (retval == -1) {
mce_log(LL_INFO, "Failed to remove name owner monitoring"
" for `%s'",sender);
goto EXIT;
}
rethink_als_status();
EXIT:
if( !dbus_message_get_no_reply(msg) ) {
DBusMessage *reply = dbus_new_method_reply(msg);
dbus_send_message(reply), reply = 0;
}
return TRUE;
}
static DBusMessage *pptp_get_sec(struct connman_task *task,
DBusMessage *msg, void *user_data)
{
const char *user, *passwd;
struct vpn_provider *provider = user_data;
DBusMessage *reply;
if (dbus_message_get_no_reply(msg))
return NULL;
user = vpn_provider_get_string(provider, "PPTP.User");
passwd = vpn_provider_get_string(provider, "PPTP.Password");
if (!user || strlen(user) == 0 ||
!passwd || strlen(passwd) == 0)
return NULL;
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
dbus_message_append_args(reply, DBUS_TYPE_STRING, &user,
DBUS_TYPE_STRING, &passwd,
DBUS_TYPE_INVALID);
return reply;
}
/**
* 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;
}
/**
* D-Bus callback for the get color profile method call
*
* @param msg The D-Bus message
* @return TRUE
*/
static gboolean color_profile_get_req_dbus_cb(DBusMessage *const msg)
{
mce_log(LL_DEBUG, "Received get color profile request");
if( dbus_message_get_no_reply(msg) )
goto EXIT;
send_current_color_profile(msg);
EXIT:
return TRUE;
}
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;
}
/** D-Bus callback for the add activity callback method call
*
* @param req The D-Bus message
*
* @return TRUE
*/
static gboolean mia_dbus_add_activity_action_cb(DBusMessage *const req)
{
const char *sender = dbus_message_get_sender(req);
DBusError err = DBUS_ERROR_INIT;
const char *service = 0;
const char *path = 0;
const char *interface = 0;
const char *method = 0;
dbus_bool_t res = false;
if( !sender )
goto EXIT;
mce_log(LL_DEVEL, "Add activity callback request from %s",
mce_dbus_get_name_owner_ident(sender));
if( !dbus_message_get_args(req, &err,
DBUS_TYPE_STRING, &service,
DBUS_TYPE_STRING, &path,
DBUS_TYPE_STRING, &interface,
DBUS_TYPE_STRING, &method,
DBUS_TYPE_INVALID) ) {
mce_log(LL_ERR, "Failed to get arguments: %s: %s",
err.name, err.message);
goto EXIT;
}
res = mia_activity_action_add(sender, service, path, interface, method);
EXIT:
if( !dbus_message_get_no_reply(req) ) {
DBusMessage *rsp = dbus_new_method_reply(req);
if( !dbus_message_append_args(rsp,
DBUS_TYPE_BOOLEAN, &res,
DBUS_TYPE_INVALID) ) {
mce_log(LL_ERR, "Failed to append reply argument");
dbus_message_unref(rsp);
}
else {
dbus_send_message(rsp);
}
}
dbus_error_free(&err);
return TRUE;
}
/**
* 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;
}
/** D-Bus callback for the remove activity callback method call
*
* @param req The D-Bus message
*
* @return TRUE
*/
static gboolean mia_dbus_remove_activity_action_cb(DBusMessage *const req)
{
const char *sender = dbus_message_get_sender(req);
if( !sender )
goto EXIT;
mce_log(LL_DEVEL, "Remove activity callback request from %s",
mce_dbus_get_name_owner_ident(sender));
mia_activity_action_remove(sender);
EXIT:
if( !dbus_message_get_no_reply(req) ) {
DBusMessage *reply = dbus_new_method_reply(req);
dbus_send_message(reply);
}
return TRUE;
}
int
my_test_peek_reply (NihDBusMessage *message,
const char * value)
{
DBusMessage * reply;
DBusMessageIter iter;
nih_assert (message != NULL);
nih_assert (value != NULL);
/* If the sender doesn't care about a reply, don't bother wasting
* effort constructing and sending one.
*/
if (dbus_message_get_no_reply (message->message))
return 0;
/* Construct the reply message. */
reply = dbus_message_new_method_return (message->message);
if (! reply)
return -1;
dbus_message_iter_init_append (reply, &iter);
/* Marshal a char * onto the message */
if (! dbus_message_iter_append_basic (&iter, DBUS_TYPE_STRING, &value)) {
dbus_message_unref (reply);
return -1;
}
/* Send the reply, appending it to the outgoing queue. */
if (! dbus_connection_send (message->connection, reply, NULL)) {
dbus_message_unref (reply);
return -1;
}
dbus_message_unref (reply);
return 0;
}
/** D-Bus callback for the color profile change method call
*
* @param msg The D-Bus message
* @return TRUE
*/
static gboolean color_profile_change_req_dbus_cb(DBusMessage *const msg)
{
mce_log(LL_DEVEL, "Received set color profile request from %s",
mce_dbus_get_message_sender_ident(msg));
const char *val = 0;
DBusError err = DBUS_ERROR_INIT;
dbus_bool_t ack = FALSE;
DBusMessage *rsp = 0;
if( !dbus_message_get_args(msg, &err,
DBUS_TYPE_STRING, &val,
DBUS_TYPE_INVALID)) {
// XXX: should we return an error instead?
mce_log(LL_ERR, "Failed to get argument from %s.%s: %s: %s",
MCE_REQUEST_IF, MCE_COLOR_PROFILE_CHANGE_REQ,
err.name, err.message);
}
else {
if( set_color_profile(val) )
ack = TRUE;
}
if( dbus_message_get_no_reply(msg) )
goto EXIT;
if( !(rsp = dbus_message_new_method_return(msg)) )
goto EXIT;
dbus_message_append_args(rsp,
DBUS_TYPE_BOOLEAN, &ack,
DBUS_TYPE_INVALID);
EXIT:
if( rsp ) dbus_send_message(rsp), rsp = 0;
dbus_error_free(&err);
return TRUE;
}
/** D-Bus callback for radio states change method call
*
* @todo Decide on error handling policy
*
* @param msg The D-Bus message
*
* @return TRUE on success, FALSE on failure
*/
static gboolean mrs_dbus_set_radio_states_cb(DBusMessage *const msg)
{
dbus_bool_t no_reply = dbus_message_get_no_reply(msg);
gboolean status = FALSE;
dbus_uint32_t states = 0;
dbus_uint32_t mask = 0;
DBusError error = DBUS_ERROR_INIT;
mce_log(LL_DEVEL, "Received radio states change request from %s",
mce_dbus_get_message_sender_ident(msg));
if (dbus_message_get_args(msg, &error,
DBUS_TYPE_UINT32, &states,
DBUS_TYPE_UINT32, &mask,
DBUS_TYPE_INVALID) == FALSE) {
// XXX: should we return an error instead?
mce_log(LL_CRIT,
"Failed to get argument from %s.%s: %s",
MCE_REQUEST_IF, MCE_RADIO_STATES_CHANGE_REQ,
error.message);
goto EXIT;
}
mrs_modify_radio_states(states, mask);
if (no_reply == FALSE) {
DBusMessage *reply = dbus_new_method_reply(msg);
status = dbus_send_message(reply);
} else {
status = TRUE;
}
EXIT:
dbus_error_free(&error);
return status;
}
/**
* wpas_iface_message_handler - Dispatch messages for interfaces or networks
* @connection: Connection to the system message bus
* @message: An incoming dbus message
* @user_data: A pointer to a dbus control interface data structure
* Returns: Whether or not the message was handled
*
* This function dispatches all incoming dbus messages for network interfaces,
* or objects owned by them, such as scanned BSSIDs and configured networks.
*/
static DBusHandlerResult wpas_iface_message_handler(DBusConnection *connection,
DBusMessage *message,
void *user_data)
{
struct wpa_supplicant *wpa_s = user_data;
const char *method = dbus_message_get_member(message);
const char *path = dbus_message_get_path(message);
const char *msg_interface = dbus_message_get_interface(message);
char *iface_obj_path = NULL;
char *network = NULL;
char *bssid = NULL;
DBusMessage *reply = NULL;
/* Caller must specify a message interface */
if (!msg_interface)
goto out;
iface_obj_path = wpas_dbus_decompose_object_path(path, &network,
&bssid);
if (iface_obj_path == NULL) {
reply = wpas_dbus_new_invalid_iface_error(message);
goto out;
}
/* Make sure the message's object path actually refers to the
* wpa_supplicant structure it's supposed to (which is wpa_s)
*/
if (wpa_supplicant_get_iface_by_dbus_path(wpa_s->global,
iface_obj_path) != wpa_s) {
reply = wpas_dbus_new_invalid_iface_error(message);
goto out;
}
if (network && !strcmp(msg_interface, WPAS_DBUS_IFACE_NETWORK)) {
/* A method for one of this interface's configured networks */
int nid = strtoul(network, NULL, 10);
if (errno != EINVAL)
reply = wpas_dispatch_network_method(message, wpa_s,
nid);
else
reply = wpas_dbus_new_invalid_network_error(message);
} else if (bssid && !strcmp(msg_interface, WPAS_DBUS_IFACE_BSSID)) {
/* A method for one of this interface's scanned BSSIDs */
reply = wpas_dispatch_bssid_method(message, wpa_s, bssid);
} else if (!strcmp(msg_interface, WPAS_DBUS_IFACE_INTERFACE)) {
/* A method for an interface only. */
if (!strcmp(method, "scan"))
reply = wpas_dbus_iface_scan(message, wpa_s);
else if (!strcmp(method, "scanResults"))
reply = wpas_dbus_iface_scan_results(message, wpa_s);
else if (!strcmp(method, "addNetwork"))
reply = wpas_dbus_iface_add_network(message, wpa_s);
else if (!strcmp(method, "removeNetwork"))
reply = wpas_dbus_iface_remove_network(message, wpa_s);
else if (!strcmp(method, "selectNetwork"))
reply = wpas_dbus_iface_select_network(message, wpa_s);
else if (!strcmp(method, "capabilities"))
reply = wpas_dbus_iface_capabilities(message, wpa_s);
else if (!strcmp(method, "disconnect"))
reply = wpas_dbus_iface_disconnect(message, wpa_s);
else if (!strcmp(method, "setAPScan"))
reply = wpas_dbus_iface_set_ap_scan(message, wpa_s);
else if (!strcmp(method, "setSmartcardModules"))
reply = wpas_dbus_iface_set_smartcard_modules(message,
wpa_s);
else if (!strcmp(method, "state"))
reply = wpas_dbus_iface_get_state(message, wpa_s);
else if (!strcmp(method, "scanning"))
reply = wpas_dbus_iface_get_scanning(message, wpa_s);
else if (!strcmp(method, "setBlobs"))
reply = wpas_dbus_iface_set_blobs(message, wpa_s);
else if (!strcmp(method, "removeBlobs"))
reply = wpas_dbus_iface_remove_blobs(message, wpa_s);
#ifdef CONFIG_WPS
else if (!os_strcmp(method, "wpsPbc"))
reply = wpas_dbus_iface_wps_pbc(message, wpa_s);
else if (!os_strcmp(method, "wpsPin"))
reply = wpas_dbus_iface_wps_pin(message, wpa_s);
else if (!os_strcmp(method, "wpsReg"))
reply = wpas_dbus_iface_wps_reg(message, wpa_s);
#endif /* CONFIG_WPS */
else if (!os_strcmp(method, "flush"))
reply = wpas_dbus_iface_flush(message, wpa_s);
}
/* If the message was handled, send back the reply */
if (reply) {
if (!dbus_message_get_no_reply(message))
dbus_connection_send(connection, reply, NULL);
dbus_message_unref(reply);
}
out:
os_free(iface_obj_path);
os_free(network);
os_free(bssid);
return reply ? DBUS_HANDLER_RESULT_HANDLED :
DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
/**
* @ingroup DBusMessageInternals
* Unit test for DBusMessage.
*
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_message_test (const char *test_data_dir)
{
DBusMessage *message, *message_without_unix_fds;
DBusMessageLoader *loader;
int i;
const char *data;
DBusMessage *copy;
const char *name1;
const char *name2;
const dbus_uint32_t our_uint32_array[] =
{ 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
const dbus_int32_t our_int32_array[] =
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
#ifdef DBUS_HAVE_INT64
const dbus_uint64_t our_uint64_array[] =
{ 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
const dbus_int64_t our_int64_array[] =
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
#endif
const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" };
const char **v_ARRAY_STRING = our_string_array;
const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
const double *v_ARRAY_DOUBLE = our_double_array;
const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 };
const unsigned char *v_ARRAY_BYTE = our_byte_array;
const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE };
const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
char sig[64];
const char *s;
const char *v_STRING;
double v_DOUBLE;
dbus_int16_t v_INT16;
dbus_uint16_t v_UINT16;
dbus_int32_t v_INT32;
dbus_uint32_t v_UINT32;
#ifdef DBUS_HAVE_INT64
dbus_int64_t v_INT64;
dbus_uint64_t v_UINT64;
#endif
unsigned char v_BYTE;
unsigned char v2_BYTE;
dbus_bool_t v_BOOLEAN;
DBusMessageIter iter, array_iter, struct_iter;
#ifdef HAVE_UNIX_FD_PASSING
int v_UNIX_FD;
#endif
char **decomposed;
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"TestMethod");
_dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
_dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface",
"TestMethod"));
_dbus_assert (strcmp (dbus_message_get_path (message),
"/org/freedesktop/TestPath") == 0);
dbus_message_set_serial (message, 1234);
/* string length including nul byte not a multiple of 4 */
if (!dbus_message_set_sender (message, "org.foo.bar1"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (dbus_message_has_sender (message, "org.foo.bar1"));
dbus_message_set_reply_serial (message, 5678);
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
if (!dbus_message_set_sender (message, NULL))
_dbus_assert_not_reached ("out of memory");
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
_dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1"));
_dbus_assert (dbus_message_get_serial (message) == 1234);
_dbus_assert (dbus_message_get_reply_serial (message) == 5678);
_dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
_dbus_assert (dbus_message_get_no_reply (message) == FALSE);
dbus_message_set_no_reply (message, TRUE);
_dbus_assert (dbus_message_get_no_reply (message) == TRUE);
dbus_message_set_no_reply (message, FALSE);
_dbus_assert (dbus_message_get_no_reply (message) == FALSE);
/* Set/get some header fields */
if (!dbus_message_set_path (message, "/foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
/* Set/get them with longer values */
if (!dbus_message_set_path (message, "/foo/bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo/bar") == 0);
if (!dbus_message_set_interface (message, "org.Foo.Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo.Bar") == 0);
if (!dbus_message_set_member (message, "BarFoo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"BarFoo") == 0);
/* Realloc shorter again */
if (!dbus_message_set_path (message, "/foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
/* Path decomposing */
dbus_message_set_path (message, NULL);
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed == NULL);
dbus_free_string_array (decomposed);
dbus_message_set_path (message, "/");
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed != NULL);
_dbus_assert (decomposed[0] == NULL);
dbus_free_string_array (decomposed);
dbus_message_set_path (message, "/a/b");
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed != NULL);
_dbus_assert (strcmp (decomposed[0], "a") == 0);
_dbus_assert (strcmp (decomposed[1], "b") == 0);
_dbus_assert (decomposed[2] == NULL);
dbus_free_string_array (decomposed);
dbus_message_set_path (message, "/spam/eggs");
dbus_message_get_path_decomposed (message, &decomposed);
_dbus_assert (decomposed != NULL);
_dbus_assert (strcmp (decomposed[0], "spam") == 0);
_dbus_assert (strcmp (decomposed[1], "eggs") == 0);
_dbus_assert (decomposed[2] == NULL);
dbus_free_string_array (decomposed);
dbus_message_unref (message);
/* Test the vararg functions */
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"TestMethod");
dbus_message_set_serial (message, 1);
dbus_message_set_reply_serial (message, 5678);
v_INT16 = -0x123;
v_UINT16 = 0x123;
v_INT32 = -0x12345678;
v_UINT32 = 0x12300042;
#ifdef DBUS_HAVE_INT64
v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
#endif
v_STRING = "Test string";
v_DOUBLE = 3.14159;
v_BOOLEAN = TRUE;
v_BYTE = 42;
v2_BYTE = 24;
#ifdef HAVE_UNIX_FD_PASSING
v_UNIX_FD = 1;
#endif
dbus_message_append_args (message,
DBUS_TYPE_INT16, &v_INT16,
DBUS_TYPE_UINT16, &v_UINT16,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_UINT32, &v_UINT32,
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_INT64, &v_INT64,
DBUS_TYPE_UINT64, &v_UINT64,
#endif
DBUS_TYPE_STRING, &v_STRING,
DBUS_TYPE_DOUBLE, &v_DOUBLE,
DBUS_TYPE_BOOLEAN, &v_BOOLEAN,
DBUS_TYPE_BYTE, &v_BYTE,
DBUS_TYPE_BYTE, &v2_BYTE,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32,
_DBUS_N_ELEMENTS (our_uint32_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32,
_DBUS_N_ELEMENTS (our_int32_array),
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64,
_DBUS_N_ELEMENTS (our_uint64_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64,
_DBUS_N_ELEMENTS (our_int64_array),
#endif
DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE,
_DBUS_N_ELEMENTS (our_double_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE,
_DBUS_N_ELEMENTS (our_byte_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN,
_DBUS_N_ELEMENTS (our_boolean_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING,
_DBUS_N_ELEMENTS (our_string_array),
DBUS_TYPE_INVALID);
i = 0;
sig[i++] = DBUS_TYPE_INT16;
sig[i++] = DBUS_TYPE_UINT16;
sig[i++] = DBUS_TYPE_INT32;
sig[i++] = DBUS_TYPE_UINT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_INT64;
sig[i++] = DBUS_TYPE_UINT64;
#endif
sig[i++] = DBUS_TYPE_STRING;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_BOOLEAN;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_UINT32;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_UINT64;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT64;
#endif
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_BOOLEAN;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_STRING;
message_without_unix_fds = dbus_message_copy(message);
_dbus_assert(message_without_unix_fds);
#ifdef HAVE_UNIX_FD_PASSING
dbus_message_append_args (message,
DBUS_TYPE_UNIX_FD, &v_UNIX_FD,
DBUS_TYPE_INVALID);
sig[i++] = DBUS_TYPE_UNIX_FD;
#endif
sig[i++] = DBUS_TYPE_INVALID;
_dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
_dbus_verbose ("HEADER\n");
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose ("BODY\n");
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
_dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n",
sig, dbus_message_get_signature (message));
s = dbus_message_get_signature (message);
_dbus_assert (dbus_message_has_signature (message, sig));
_dbus_assert (strcmp (s, sig) == 0);
verify_test_message (message);
copy = dbus_message_copy (message);
_dbus_assert (dbus_message_get_reply_serial (message) ==
dbus_message_get_reply_serial (copy));
_dbus_assert (message->header.padding == copy->header.padding);
_dbus_assert (_dbus_string_get_length (&message->header.data) ==
_dbus_string_get_length (©->header.data));
_dbus_assert (_dbus_string_get_length (&message->body) ==
_dbus_string_get_length (©->body));
verify_test_message (copy);
name1 = dbus_message_get_interface (message);
name2 = dbus_message_get_interface (copy);
_dbus_assert (strcmp (name1, name2) == 0);
name1 = dbus_message_get_member (message);
name2 = dbus_message_get_member (copy);
_dbus_assert (strcmp (name1, name2) == 0);
dbus_message_unref (copy);
/* Message loader test */
dbus_message_lock (message);
loader = _dbus_message_loader_new ();
/* check ref/unref */
_dbus_message_loader_ref (loader);
_dbus_message_loader_unref (loader);
/* Write the header data one byte at a time */
data = _dbus_string_get_const_data (&message->header.data);
for (i = 0; i < _dbus_string_get_length (&message->header.data); i++)
{
DBusString *buffer;
_dbus_message_loader_get_buffer (loader, &buffer);
_dbus_string_append_byte (buffer, data[i]);
_dbus_message_loader_return_buffer (loader, buffer, 1);
}
/* Write the body data one byte at a time */
data = _dbus_string_get_const_data (&message->body);
for (i = 0; i < _dbus_string_get_length (&message->body); i++)
{
DBusString *buffer;
_dbus_message_loader_get_buffer (loader, &buffer);
_dbus_string_append_byte (buffer, data[i]);
_dbus_message_loader_return_buffer (loader, buffer, 1);
}
#ifdef HAVE_UNIX_FD_PASSING
{
int *unix_fds;
unsigned n_unix_fds;
/* Write unix fd */
_dbus_message_loader_get_unix_fds(loader, &unix_fds, &n_unix_fds);
_dbus_assert(n_unix_fds > 0);
_dbus_assert(message->n_unix_fds == 1);
unix_fds[0] = _dbus_dup(message->unix_fds[0], NULL);
_dbus_assert(unix_fds[0] >= 0);
_dbus_message_loader_return_unix_fds(loader, unix_fds, 1);
}
#endif
dbus_message_unref (message);
/* Now pop back the message */
if (!_dbus_message_loader_queue_messages (loader))
_dbus_assert_not_reached ("no memory to queue messages");
if (_dbus_message_loader_get_is_corrupted (loader))
_dbus_assert_not_reached ("message loader corrupted");
message = _dbus_message_loader_pop_message (loader);
if (!message)
_dbus_assert_not_reached ("received a NULL message");
if (dbus_message_get_reply_serial (message) != 5678)
_dbus_assert_not_reached ("reply serial fields differ");
dbus_message_unref (message);
/* ovveride the serial, since it was reset by dbus_message_copy() */
dbus_message_set_serial(message_without_unix_fds, 8901);
dbus_message_lock (message_without_unix_fds);
verify_test_message (message_without_unix_fds);
{
/* Marshal and demarshal the message. */
DBusMessage *message2;
DBusError error = DBUS_ERROR_INIT;
char *marshalled = NULL;
int len = 0;
char garbage_header[DBUS_MINIMUM_HEADER_SIZE] = "xxx";
if (!dbus_message_marshal (message_without_unix_fds, &marshalled, &len))
_dbus_assert_not_reached ("failed to marshal message");
_dbus_assert (len != 0);
_dbus_assert (marshalled != NULL);
_dbus_assert (dbus_message_demarshal_bytes_needed (marshalled, len) == len);
message2 = dbus_message_demarshal (marshalled, len, &error);
_dbus_assert (message2 != NULL);
_dbus_assert (!dbus_error_is_set (&error));
verify_test_message (message2);
dbus_message_unref (message2);
dbus_free (marshalled);
/* Demarshal invalid message. */
message2 = dbus_message_demarshal ("invalid", 7, &error);
_dbus_assert (message2 == NULL);
_dbus_assert (dbus_error_is_set (&error));
dbus_error_free (&error);
/* Demarshal invalid (empty) message. */
message2 = dbus_message_demarshal ("", 0, &error);
_dbus_assert (message2 == NULL);
_dbus_assert (dbus_error_is_set (&error));
dbus_error_free (&error);
/* Bytes needed to demarshal empty message: 0 (more) */
_dbus_assert (dbus_message_demarshal_bytes_needed ("", 0) == 0);
/* Bytes needed to demarshal invalid message: -1 (error). */
_dbus_assert (dbus_message_demarshal_bytes_needed (garbage_header, DBUS_MINIMUM_HEADER_SIZE) == -1);
}
dbus_message_unref (message_without_unix_fds);
_dbus_message_loader_unref (loader);
check_memleaks ();
_dbus_check_fdleaks();
/* Check that we can abandon a container */
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"Method");
dbus_message_iter_init_append (message, &iter);
_dbus_assert (dbus_message_iter_open_container (&iter, DBUS_TYPE_ARRAY,
(DBUS_STRUCT_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_STRUCT_END_CHAR_AS_STRING),
&array_iter));
_dbus_assert (dbus_message_iter_open_container (&array_iter, DBUS_TYPE_STRUCT,
NULL, &struct_iter));
s = "peaches";
_dbus_assert (dbus_message_iter_append_basic (&struct_iter, DBUS_TYPE_STRING,
&s));
/* uh-oh, error, try and unwind */
dbus_message_iter_abandon_container (&array_iter, &struct_iter);
dbus_message_iter_abandon_container (&array_iter, &iter);
dbus_message_unref (message);
/* Load all the sample messages from the message factory */
{
DBusMessageDataIter diter;
DBusMessageData mdata;
int count;
reset_validities_seen ();
count = 0;
_dbus_message_data_iter_init (&diter);
while (_dbus_message_data_iter_get_and_next (&diter,
&mdata))
{
if (!dbus_internal_do_not_use_try_message_data (&mdata.data,
mdata.expected_validity))
{
_dbus_warn ("expected validity %d and did not get it\n",
mdata.expected_validity);
_dbus_assert_not_reached ("message data failed");
}
_dbus_message_data_free (&mdata);
count += 1;
}
printf ("%d sample messages tested\n", count);
print_validities_seen (FALSE);
print_validities_seen (TRUE);
}
check_memleaks ();
_dbus_check_fdleaks();
/* Now load every message in test_data_dir if we have one */
if (test_data_dir == NULL)
return TRUE;
return dbus_internal_do_not_use_foreach_message_file (test_data_dir,
(DBusForeachMessageFileFunc)
dbus_internal_do_not_use_try_message_file,
NULL);
}
DBusHandlerResult
my_com_netsplit_Nih_Test_Method_method (NihDBusObject * object,
NihDBusMessage *message)
{
DBusMessageIter iter;
DBusMessage * reply;
MyMethodStructure *structure;
DBusMessageIter structure_iter;
const char * structure_item0;
uint32_t structure_item1;
nih_assert (object != NULL);
nih_assert (message != NULL);
/* Iterate the arguments to the message and demarshal into arguments
* for our own function call.
*/
dbus_message_iter_init (message->message, &iter);
if (dbus_message_iter_get_arg_type (&iter) != DBUS_TYPE_INVALID) {
reply = dbus_message_new_error (message->message, DBUS_ERROR_INVALID_ARGS,
"Invalid arguments to Method method");
if (! reply)
return DBUS_HANDLER_RESULT_NEED_MEMORY;
if (! dbus_connection_send (message->connection, reply, NULL)) {
dbus_message_unref (reply);
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
dbus_message_unref (reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
/* Call the handler function */
nih_error_push_context ();
if (my_method (object->data, message, &structure) < 0) {
NihError *err;
err = nih_error_get ();
if (err->number == ENOMEM) {
nih_free (err);
nih_error_pop_context ();
return DBUS_HANDLER_RESULT_NEED_MEMORY;
} else if (err->number == NIH_DBUS_ERROR) {
NihDBusError *dbus_err = (NihDBusError *)err;
reply = NIH_MUST (dbus_message_new_error (message->message, dbus_err->name, err->message));
nih_free (err);
nih_error_pop_context ();
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
dbus_message_unref (reply);
return DBUS_HANDLER_RESULT_HANDLED;
} else {
reply = NIH_MUST (dbus_message_new_error (message->message, DBUS_ERROR_FAILED, err->message));
nih_free (err);
nih_error_pop_context ();
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
dbus_message_unref (reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
}
nih_error_pop_context ();
/* If the sender doesn't care about a reply, don't bother wasting
* effort constructing and sending one.
*/
if (dbus_message_get_no_reply (message->message))
return DBUS_HANDLER_RESULT_HANDLED;
do {
__label__ enomem;
/* Construct the reply message. */
reply = dbus_message_new_method_return (message->message);
if (! reply)
goto enomem;
dbus_message_iter_init_append (reply, &iter);
/* Marshal a structure onto the message */
if (! dbus_message_iter_open_container (&iter, DBUS_TYPE_STRUCT, NULL, &structure_iter)) {
dbus_message_unref (reply);
reply = NULL;
goto enomem;
}
structure_item0 = structure->item0;
/* Marshal a char * onto the message */
if (! dbus_message_iter_append_basic (&structure_iter, DBUS_TYPE_STRING, &structure_item0)) {
dbus_message_iter_abandon_container (&iter, &structure_iter);
dbus_message_unref (reply);
reply = NULL;
goto enomem;
}
structure_item1 = structure->item1;
/* Marshal a uint32_t onto the message */
if (! dbus_message_iter_append_basic (&structure_iter, DBUS_TYPE_UINT32, &structure_item1)) {
dbus_message_iter_abandon_container (&iter, &structure_iter);
dbus_message_unref (reply);
reply = NULL;
goto enomem;
}
if (! dbus_message_iter_close_container (&iter, &structure_iter)) {
dbus_message_unref (reply);
reply = NULL;
goto enomem;
}
enomem: __attribute__ ((unused));
} while (! reply);
/* Send the reply, appending it to the outgoing queue. */
NIH_MUST (dbus_connection_send (message->connection, reply, NULL));
dbus_message_unref (reply);
return DBUS_HANDLER_RESULT_HANDLED;
}
static DBusHandlerResult
ping_object_message_handler_cb(DBusConnection* a_conn, DBusMessage *a_message, void* a_user_data)
{
/* Make compiler happy */
a_conn = a_conn;
a_user_data = a_user_data;
/* Is it our call?*/
if (dbus_message_is_method_call(a_message, INTERFACE, METHOD))
{
unsigned counter;
unsigned orig_timestamp;
if ( dbus_message_get_args(a_message, &s_error,
DBUS_TYPE_UINT32, &counter,
DBUS_TYPE_UINT32, &orig_timestamp,
DBUS_TYPE_INVALID) )
{
const unsigned now = get_time_us();
/* We shall be careful: message can be lost */
const unsigned diff = (now > orig_timestamp ? now - orig_timestamp : 0);
SERVER* server = s_server; /* Probably will be identified for each client */
/* If we're measuring the roundtrip performance, then just reply
and be done with it */
if (!dbus_message_get_no_reply(a_message))
{
DBusMessage *reply;
unsigned timestamp = get_time_us();
reply = dbus_message_new_method_return(a_message);
if (NULL == reply)
{
fatal("DPONG: ERROR: dbus_message_new_method_return() failure.");
}
dbus_message_append_args(reply,
DBUS_TYPE_UINT32, &counter,
DBUS_TYPE_UINT32, &orig_timestamp,
DBUS_TYPE_UINT32, ×tamp,
DBUS_TYPE_INVALID);
if (!dbus_connection_send(a_conn, reply, NULL))
{
fprintf(stderr, "DPONG: WARNING: dbus_connection_send() failure.\n");
}
dbus_message_unref(reply);
dbus_connection_flush(a_conn);
}
else
{
/* Check message losing */
if (counter == server->counter)
{
server->recv++;
if (diff > 0)
{
if (0 == server->min_time || server->min_time > diff)
server->min_time = diff;
if (0 == server->max_time || server->max_time < diff)
server->max_time = diff;
server->tot_time += diff;
}
}
else
{
/* Number of messages lost */
server->lost += (server->counter < counter ? counter - server->counter : server->report - server->counter);
}
/* Increase the index of message */
server->counter = counter + 1;
/* Reporting if it necessary */
if (0 == (server->counter % server->report))
{
/* fprintf (stdout, "dpong timestamp: %u microseconds\n", get_time_us()); */
fprintf (stdout, "MESSAGES recv %u lost %u LATENCY min %5u avg %5u max %5u THROUGHPUT %.1f m/s\n",
server->recv, server->lost,
server->min_time, (server->tot_time / server->recv), server->max_time,
server->recv/((double)(get_time_us()-server->initial_ts)/1000000)
);
/* Setup values for new test cycle */
if (server->counter < server->report)
{
/* We lose some messages and receive the first one from
the new cycle */
server->recv = 1;
server->lost = counter - 1;
server->min_time = diff;
server->tot_time = diff;
server->max_time = diff;
}
else
{
/* Normal flow, all messages received */
server->recv = 0;
server->lost = 0;
server->min_time = 0;
server->tot_time = 0;
server->max_time = 0;
server->initial_ts = get_time_us();
}
}
}
return 0;
}
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
} /* ping_object_message_handler_cb */
gboolean
ibus_message_get_no_reply (IBusMessage *message)
{
return dbus_message_get_no_reply (message);
}
/**
* Process a opts_set D-Bus request.
*/
static bool
cdbus_process_opts_set(session_t *ps, DBusMessage *msg) {
const char *target = NULL;
if (!cdbus_msg_get_arg(msg, 0, DBUS_TYPE_STRING, &target))
return false;
#define cdbus_m_opts_set_do(tgt, type, real_type) \
if (!strcmp(MSTR(tgt), target)) { \
real_type val; \
if (!cdbus_msg_get_arg(msg, 1, type, &val)) \
return false; \
ps->o.tgt = val; \
goto cdbus_process_opts_set_success; \
}
// unredir_if_possible
if (!strcmp("unredir_if_possible", target)) {
dbus_bool_t val = FALSE;
if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_BOOLEAN, &val))
return false;
if (ps->o.unredir_if_possible != val) {
ps->o.unredir_if_possible = val;
ps->ev_received = true;
}
goto cdbus_process_opts_set_success;
}
// track_focus
if (!strcmp("track_focus", target)) {
dbus_bool_t val = FALSE;
if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_BOOLEAN, &val))
return false;
// You could enable this option, but never turn if off
if (val) {
opts_init_track_focus(ps);
}
goto cdbus_process_opts_set_success;
}
// vsync
if (!strcmp("vsync", target)) {
const char * val = NULL;
if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_STRING, &val))
return false;
if (!parse_vsync(ps, val)) {
printf_errf("(): " CDBUS_ERROR_BADARG_S, 1, "Value invalid.");
cdbus_reply_err(ps, msg, CDBUS_ERROR_BADARG, CDBUS_ERROR_BADARG_S, 1, "Value invalid.");
}
else if (!vsync_init(ps)) {
printf_errf("(): " CDBUS_ERROR_CUSTOM_S, "Failed to initialize specified VSync method.");
cdbus_reply_err(ps, msg, CDBUS_ERROR_CUSTOM, CDBUS_ERROR_CUSTOM_S, "Failed to initialize specified VSync method.");
}
else
goto cdbus_process_opts_set_success;
return true;
}
#undef cdbus_m_opts_set_do
printf_errf("(): " CDBUS_ERROR_BADTGT_S, target);
cdbus_reply_err(ps, msg, CDBUS_ERROR_BADTGT, CDBUS_ERROR_BADTGT_S, target);
return true;
cdbus_process_opts_set_success:
if (!dbus_message_get_no_reply(msg))
cdbus_reply_bool(ps, msg, true);
return true;
}
/**
* Process a win_set D-Bus request.
*/
static bool
cdbus_process_win_set(session_t *ps, DBusMessage *msg) {
cdbus_window_t wid = None;
const char *target = NULL;
DBusError err = { };
if (!dbus_message_get_args(msg, &err,
CDBUS_TYPE_WINDOW, &wid,
DBUS_TYPE_STRING, &target,
DBUS_TYPE_INVALID)) {
printf_errf("(): Failed to parse argument of \"win_set\" (%s).",
err.message);
dbus_error_free(&err);
return false;
}
win *w = find_win(ps, wid);
if (!w) {
printf_errf("(): Window %#010x not found.", wid);
cdbus_reply_err(ps, msg, CDBUS_ERROR_BADWIN, CDBUS_ERROR_BADWIN_S, wid);
return true;
}
ps->ev_received = true;
#define cdbus_m_win_set_do(tgt, type, real_type) \
if (!strcmp(MSTR(tgt), target)) { \
real_type val; \
if (!cdbus_msg_get_arg(msg, 2, type, &val)) \
return false; \
w->tgt = val; \
goto cdbus_process_win_set_success; \
}
if (!strcmp("focused_force", target)) {
cdbus_enum_t val = UNSET;
if (!cdbus_msg_get_arg(msg, 2, CDBUS_TYPE_ENUM, &val))
return false;
win_set_focused_force(ps, w, val);
goto cdbus_process_win_set_success;
}
if (!strcmp("invert_color_force", target)) {
cdbus_enum_t val = UNSET;
if (!cdbus_msg_get_arg(msg, 2, CDBUS_TYPE_ENUM, &val))
return false;
win_set_invert_color_force(ps, w, val);
goto cdbus_process_win_set_success;
}
#undef cdbus_m_win_set_do
printf_errf("(): " CDBUS_ERROR_BADTGT_S, target);
cdbus_reply_err(ps, msg, CDBUS_ERROR_BADTGT, CDBUS_ERROR_BADTGT_S, target);
return true;
cdbus_process_win_set_success:
if (!dbus_message_get_no_reply(msg))
cdbus_reply_bool(ps, msg, true);
return true;
}
/**
* Process a message from D-Bus.
*/
static void
cdbus_process(session_t *ps, DBusMessage *msg) {
bool success = false;
#define cdbus_m_ismethod(method) \
dbus_message_is_method_call(msg, CDBUS_INTERFACE_NAME, method)
if (cdbus_m_ismethod("reset")) {
ps->reset = true;
if (!dbus_message_get_no_reply(msg))
cdbus_reply_bool(ps, msg, true);
success = true;
}
else if (cdbus_m_ismethod("list_win")) {
success = cdbus_process_list_win(ps, msg);
}
else if (cdbus_m_ismethod("win_get")) {
success = cdbus_process_win_get(ps, msg);
}
else if (cdbus_m_ismethod("win_set")) {
success = cdbus_process_win_set(ps, msg);
}
else if (cdbus_m_ismethod("find_win")) {
success = cdbus_process_find_win(ps, msg);
}
else if (cdbus_m_ismethod("opts_get")) {
success = cdbus_process_opts_get(ps, msg);
}
else if (cdbus_m_ismethod("opts_set")) {
success = cdbus_process_opts_set(ps, msg);
}
#undef cdbus_m_ismethod
else if (dbus_message_is_method_call(msg,
"org.freedesktop.DBus.Introspectable", "Introspect")) {
success = cdbus_process_introspect(ps, msg);
}
else if (dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameAcquired")
|| dbus_message_is_signal(msg, "org.freedesktop.DBus", "NameLost")) {
success = true;
}
else {
if (DBUS_MESSAGE_TYPE_ERROR == dbus_message_get_type(msg)) {
printf_errf("(): Error message of path \"%s\" "
"interface \"%s\", member \"%s\", error \"%s\"",
dbus_message_get_path(msg), dbus_message_get_interface(msg),
dbus_message_get_member(msg), dbus_message_get_error_name(msg));
}
else {
printf_errf("(): Illegal message of type \"%s\", path \"%s\" "
"interface \"%s\", member \"%s\"",
cdbus_repr_msgtype(msg), dbus_message_get_path(msg),
dbus_message_get_interface(msg), dbus_message_get_member(msg));
}
if (DBUS_MESSAGE_TYPE_METHOD_CALL == dbus_message_get_type(msg)
&& !dbus_message_get_no_reply(msg))
cdbus_reply_err(ps, msg, CDBUS_ERROR_BADMSG, CDBUS_ERROR_BADMSG_S);
success = true;
}
// If the message could not be processed, and an reply is expected, return
// an empty reply.
if (!success && DBUS_MESSAGE_TYPE_METHOD_CALL == dbus_message_get_type(msg)
&& !dbus_message_get_no_reply(msg))
cdbus_reply_err(ps, msg, CDBUS_ERROR_UNKNOWN, CDBUS_ERROR_UNKNOWN_S);
// Free the message
dbus_message_unref(msg);
}
/**
* @ingroup DBusMessageInternals
* Unit test for DBusMessage.
*
* @returns #TRUE on success.
*/
dbus_bool_t
_dbus_message_test (const char *test_data_dir)
{
DBusMessage *message;
DBusMessageLoader *loader;
int i;
const char *data;
DBusMessage *copy;
const char *name1;
const char *name2;
const dbus_uint32_t our_uint32_array[] =
{ 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
const dbus_int32_t our_int32_array[] =
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint32_t *v_ARRAY_UINT32 = our_uint32_array;
const dbus_int32_t *v_ARRAY_INT32 = our_int32_array;
#ifdef DBUS_HAVE_INT64
const dbus_uint64_t our_uint64_array[] =
{ 0x12345678, 0x23456781, 0x34567812, 0x45678123 };
const dbus_int64_t our_int64_array[] =
{ 0x12345678, -0x23456781, 0x34567812, -0x45678123 };
const dbus_uint64_t *v_ARRAY_UINT64 = our_uint64_array;
const dbus_int64_t *v_ARRAY_INT64 = our_int64_array;
#endif
const char *our_string_array[] = { "Foo", "bar", "", "woo woo woo woo" };
const char **v_ARRAY_STRING = our_string_array;
const double our_double_array[] = { 0.1234, 9876.54321, -300.0 };
const double *v_ARRAY_DOUBLE = our_double_array;
const unsigned char our_byte_array[] = { 'a', 'b', 'c', 234 };
const unsigned char *v_ARRAY_BYTE = our_byte_array;
const dbus_bool_t our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE };
const dbus_bool_t *v_ARRAY_BOOLEAN = our_boolean_array;
char sig[64];
const char *s;
const char *v_STRING;
double v_DOUBLE;
dbus_int16_t v_INT16;
dbus_uint16_t v_UINT16;
dbus_int32_t v_INT32;
dbus_uint32_t v_UINT32;
#ifdef DBUS_HAVE_INT64
dbus_int64_t v_INT64;
dbus_uint64_t v_UINT64;
#endif
unsigned char v_BYTE;
unsigned char v2_BYTE;
dbus_bool_t v_BOOLEAN;
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"TestMethod");
_dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
_dbus_assert (dbus_message_is_method_call (message, "Foo.TestInterface",
"TestMethod"));
_dbus_assert (strcmp (dbus_message_get_path (message),
"/org/freedesktop/TestPath") == 0);
_dbus_message_set_serial (message, 1234);
/* string length including nul byte not a multiple of 4 */
if (!dbus_message_set_sender (message, "org.foo.bar1"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (dbus_message_has_sender (message, "org.foo.bar1"));
dbus_message_set_reply_serial (message, 5678);
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
if (!dbus_message_set_sender (message, NULL))
_dbus_assert_not_reached ("out of memory");
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
_dbus_assert (!dbus_message_has_sender (message, "org.foo.bar1"));
_dbus_assert (dbus_message_get_serial (message) == 1234);
_dbus_assert (dbus_message_get_reply_serial (message) == 5678);
_dbus_assert (dbus_message_has_destination (message, "org.freedesktop.DBus.TestService"));
_dbus_assert (dbus_message_get_no_reply (message) == FALSE);
dbus_message_set_no_reply (message, TRUE);
_dbus_assert (dbus_message_get_no_reply (message) == TRUE);
dbus_message_set_no_reply (message, FALSE);
_dbus_assert (dbus_message_get_no_reply (message) == FALSE);
/* Set/get some header fields */
if (!dbus_message_set_path (message, "/foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
/* Set/get them with longer values */
if (!dbus_message_set_path (message, "/foo/bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo/bar") == 0);
if (!dbus_message_set_interface (message, "org.Foo.Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo.Bar") == 0);
if (!dbus_message_set_member (message, "BarFoo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"BarFoo") == 0);
/* Realloc shorter again */
if (!dbus_message_set_path (message, "/foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_path (message),
"/foo") == 0);
if (!dbus_message_set_interface (message, "org.Foo"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_interface (message),
"org.Foo") == 0);
if (!dbus_message_set_member (message, "Bar"))
_dbus_assert_not_reached ("out of memory");
_dbus_assert (strcmp (dbus_message_get_member (message),
"Bar") == 0);
dbus_message_unref (message);
/* Test the vararg functions */
message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService",
"/org/freedesktop/TestPath",
"Foo.TestInterface",
"TestMethod");
_dbus_message_set_serial (message, 1);
dbus_message_set_reply_serial (message, 5678);
v_INT16 = -0x123;
v_UINT16 = 0x123;
v_INT32 = -0x12345678;
v_UINT32 = 0x12300042;
#ifdef DBUS_HAVE_INT64
v_INT64 = DBUS_INT64_CONSTANT (-0x123456789abcd);
v_UINT64 = DBUS_UINT64_CONSTANT (0x123456789abcd);
#endif
v_STRING = "Test string";
v_DOUBLE = 3.14159;
v_BOOLEAN = TRUE;
v_BYTE = 42;
v2_BYTE = 24;
dbus_message_append_args (message,
DBUS_TYPE_INT16, &v_INT16,
DBUS_TYPE_UINT16, &v_UINT16,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_UINT32, &v_UINT32,
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_INT64, &v_INT64,
DBUS_TYPE_UINT64, &v_UINT64,
#endif
DBUS_TYPE_STRING, &v_STRING,
DBUS_TYPE_DOUBLE, &v_DOUBLE,
DBUS_TYPE_BOOLEAN, &v_BOOLEAN,
DBUS_TYPE_BYTE, &v_BYTE,
DBUS_TYPE_BYTE, &v2_BYTE,
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, &v_ARRAY_UINT32,
_DBUS_N_ELEMENTS (our_uint32_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT32, &v_ARRAY_INT32,
_DBUS_N_ELEMENTS (our_int32_array),
#ifdef DBUS_HAVE_INT64
DBUS_TYPE_ARRAY, DBUS_TYPE_UINT64, &v_ARRAY_UINT64,
_DBUS_N_ELEMENTS (our_uint64_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_INT64, &v_ARRAY_INT64,
_DBUS_N_ELEMENTS (our_int64_array),
#endif
DBUS_TYPE_ARRAY, DBUS_TYPE_DOUBLE, &v_ARRAY_DOUBLE,
_DBUS_N_ELEMENTS (our_double_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &v_ARRAY_BYTE,
_DBUS_N_ELEMENTS (our_byte_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_BOOLEAN, &v_ARRAY_BOOLEAN,
_DBUS_N_ELEMENTS (our_boolean_array),
DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, &v_ARRAY_STRING,
_DBUS_N_ELEMENTS (our_string_array),
DBUS_TYPE_INVALID);
i = 0;
sig[i++] = DBUS_TYPE_INT16;
sig[i++] = DBUS_TYPE_UINT16;
sig[i++] = DBUS_TYPE_INT32;
sig[i++] = DBUS_TYPE_UINT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_INT64;
sig[i++] = DBUS_TYPE_UINT64;
#endif
sig[i++] = DBUS_TYPE_STRING;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_BOOLEAN;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_UINT32;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT32;
#ifdef DBUS_HAVE_INT64
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_UINT64;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_INT64;
#endif
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_DOUBLE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_BYTE;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_BOOLEAN;
sig[i++] = DBUS_TYPE_ARRAY;
sig[i++] = DBUS_TYPE_STRING;
sig[i++] = DBUS_TYPE_INVALID;
_dbus_assert (i < (int) _DBUS_N_ELEMENTS (sig));
_dbus_verbose ("HEADER\n");
_dbus_verbose_bytes_of_string (&message->header.data, 0,
_dbus_string_get_length (&message->header.data));
_dbus_verbose ("BODY\n");
_dbus_verbose_bytes_of_string (&message->body, 0,
_dbus_string_get_length (&message->body));
_dbus_verbose ("Signature expected \"%s\" actual \"%s\"\n",
sig, dbus_message_get_signature (message));
s = dbus_message_get_signature (message);
_dbus_assert (dbus_message_has_signature (message, sig));
_dbus_assert (strcmp (s, sig) == 0);
verify_test_message (message);
copy = dbus_message_copy (message);
_dbus_assert (dbus_message_get_reply_serial (message) ==
dbus_message_get_reply_serial (copy));
_dbus_assert (message->header.padding == copy->header.padding);
_dbus_assert (_dbus_string_get_length (&message->header.data) ==
_dbus_string_get_length (©->header.data));
_dbus_assert (_dbus_string_get_length (&message->body) ==
_dbus_string_get_length (©->body));
verify_test_message (copy);
name1 = dbus_message_get_interface (message);
name2 = dbus_message_get_interface (copy);
_dbus_assert (strcmp (name1, name2) == 0);
name1 = dbus_message_get_member (message);
name2 = dbus_message_get_member (copy);
_dbus_assert (strcmp (name1, name2) == 0);
dbus_message_unref (copy);
/* Message loader test */
_dbus_message_lock (message);
loader = _dbus_message_loader_new ();
/* check ref/unref */
_dbus_message_loader_ref (loader);
_dbus_message_loader_unref (loader);
/* Write the header data one byte at a time */
data = _dbus_string_get_const_data (&message->header.data);
for (i = 0; i < _dbus_string_get_length (&message->header.data); i++)
{
DBusString *buffer;
_dbus_message_loader_get_buffer (loader, &buffer);
_dbus_string_append_byte (buffer, data[i]);
_dbus_message_loader_return_buffer (loader, buffer, 1);
}
/* Write the body data one byte at a time */
data = _dbus_string_get_const_data (&message->body);
for (i = 0; i < _dbus_string_get_length (&message->body); i++)
{
DBusString *buffer;
_dbus_message_loader_get_buffer (loader, &buffer);
_dbus_string_append_byte (buffer, data[i]);
_dbus_message_loader_return_buffer (loader, buffer, 1);
}
dbus_message_unref (message);
/* Now pop back the message */
if (!_dbus_message_loader_queue_messages (loader))
_dbus_assert_not_reached ("no memory to queue messages");
if (_dbus_message_loader_get_is_corrupted (loader))
_dbus_assert_not_reached ("message loader corrupted");
message = _dbus_message_loader_pop_message (loader);
if (!message)
_dbus_assert_not_reached ("received a NULL message");
if (dbus_message_get_reply_serial (message) != 5678)
_dbus_assert_not_reached ("reply serial fields differ");
verify_test_message (message);
dbus_message_unref (message);
_dbus_message_loader_unref (loader);
check_memleaks ();
/* Load all the sample messages from the message factory */
{
DBusMessageDataIter diter;
DBusMessageData mdata;
int count;
reset_validities_seen ();
count = 0;
_dbus_message_data_iter_init (&diter);
while (_dbus_message_data_iter_get_and_next (&diter,
&mdata))
{
if (!dbus_internal_do_not_use_try_message_data (&mdata.data,
mdata.expected_validity))
{
_dbus_warn ("expected validity %d and did not get it\n",
mdata.expected_validity);
_dbus_assert_not_reached ("message data failed");
}
_dbus_message_data_free (&mdata);
count += 1;
}
printf ("%d sample messages tested\n", count);
print_validities_seen (FALSE);
print_validities_seen (TRUE);
}
check_memleaks ();
/* Now load every message in test_data_dir if we have one */
if (test_data_dir == NULL)
return TRUE;
return dbus_internal_do_not_use_foreach_message_file (test_data_dir,
(DBusForeachMessageFileFunc)
dbus_internal_do_not_use_try_message_file,
NULL);
}
/**
* Process a opts_set D-Bus request.
*/
static bool
cdbus_process_opts_set(session_t *ps, DBusMessage *msg) {
const char *target = NULL;
if (!cdbus_msg_get_arg(msg, 0, DBUS_TYPE_STRING, &target))
return false;
#define cdbus_m_opts_set_do(tgt, type, real_type) \
if (!strcmp(MSTR(tgt), target)) { \
real_type val; \
if (!cdbus_msg_get_arg(msg, 1, type, &val)) \
return false; \
ps->o.tgt = val; \
goto cdbus_process_opts_set_success; \
}
// fade_delta
if (!strcmp("fade_delta", target)) {
int32_t val = 0.0;
if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_INT32, &val))
return false;
ps->o.fade_delta = max_i(val, 1);
goto cdbus_process_opts_set_success;
}
// fade_in_step
if (!strcmp("fade_in_step", target)) {
double val = 0.0;
if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_DOUBLE, &val))
return false;
ps->o.fade_in_step = normalize_d(val) * OPAQUE;
goto cdbus_process_opts_set_success;
}
// fade_out_step
if (!strcmp("fade_out_step", target)) {
double val = 0.0;
if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_DOUBLE, &val))
return false;
ps->o.fade_out_step = normalize_d(val) * OPAQUE;
goto cdbus_process_opts_set_success;
}
// no_fading_openclose
if (!strcmp("no_fading_openclose", target)) {
dbus_bool_t val = FALSE;
if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_BOOLEAN, &val))
return false;
opts_set_no_fading_openclose(ps, val);
goto cdbus_process_opts_set_success;
}
// unredir_if_possible
if (!strcmp("unredir_if_possible", target)) {
dbus_bool_t val = FALSE;
if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_BOOLEAN, &val))
return false;
if (ps->o.unredir_if_possible != val) {
ps->o.unredir_if_possible = val;
ps->ev_received = true;
}
goto cdbus_process_opts_set_success;
}
// clear_shadow
if (!strcmp("clear_shadow", target)) {
dbus_bool_t val = FALSE;
if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_BOOLEAN, &val))
return false;
if (ps->o.clear_shadow != val) {
ps->o.clear_shadow = val;
force_repaint(ps);
}
goto cdbus_process_opts_set_success;
}
// track_focus
if (!strcmp("track_focus", target)) {
dbus_bool_t val = FALSE;
if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_BOOLEAN, &val))
return false;
// You could enable this option, but never turn if off
if (val) {
opts_init_track_focus(ps);
}
goto cdbus_process_opts_set_success;
}
// vsync
if (!strcmp("vsync", target)) {
const char * val = NULL;
if (!cdbus_msg_get_arg(msg, 1, DBUS_TYPE_STRING, &val))
return false;
vsync_deinit(ps);
if (!parse_vsync(ps, val)) {
printf_errf("(): " CDBUS_ERROR_BADARG_S, 1, "Value invalid.");
cdbus_reply_err(ps, msg, CDBUS_ERROR_BADARG, CDBUS_ERROR_BADARG_S, 1, "Value invalid.");
}
else if (!vsync_init(ps)) {
printf_errf("(): " CDBUS_ERROR_CUSTOM_S, "Failed to initialize specified VSync method.");
cdbus_reply_err(ps, msg, CDBUS_ERROR_CUSTOM, CDBUS_ERROR_CUSTOM_S, "Failed to initialize specified VSync method.");
}
else
goto cdbus_process_opts_set_success;
return true;
}
// redirected_force
if (!strcmp("redirected_force", target)) {
cdbus_enum_t val = UNSET;
if (!cdbus_msg_get_arg(msg, 1, CDBUS_TYPE_ENUM, &val))
return false;
ps->o.redirected_force = val;
force_repaint(ps);
goto cdbus_process_opts_set_success;
}
// stoppaint_force
cdbus_m_opts_set_do(stoppaint_force, CDBUS_TYPE_ENUM, cdbus_enum_t);
#undef cdbus_m_opts_set_do
printf_errf("(): " CDBUS_ERROR_BADTGT_S, target);
cdbus_reply_err(ps, msg, CDBUS_ERROR_BADTGT, CDBUS_ERROR_BADTGT_S, target);
return true;
cdbus_process_opts_set_success:
if (!dbus_message_get_no_reply(msg))
cdbus_reply_bool(ps, msg, true);
return true;
}
/**
* D-Bus callback for powerkey event triggering
*
* @param msg D-Bus message
* @return TRUE on success, FALSE on failure
*/
static gboolean trigger_powerkey_event_req_dbus_cb(DBusMessage *const msg)
{
dbus_bool_t no_reply = dbus_message_get_no_reply(msg);
DBusMessageIter iter;
dbus_uint32_t uintval;
dbus_bool_t boolval;
gint argcount = 0;
gint argtype;
gboolean status = FALSE;
DBusError error;
/* Register error channel */
dbus_error_init(&error);
mce_log(LL_DEBUG, "Received [power] button trigger request");
if (dbus_message_iter_init(msg, &iter) == FALSE) {
// XXX: should we return an error instead?
mce_log(LL_ERR,
"Failed to initialise D-Bus message iterator; "
"message has no arguments");
goto EXIT;
}
argtype = dbus_message_iter_get_arg_type(&iter);
argcount++;
switch (argtype) {
case DBUS_TYPE_BOOLEAN:
dbus_message_iter_get_basic(&iter, &boolval);
uintval = (boolval == TRUE) ? 1 : 0;
break;
case DBUS_TYPE_UINT32:
dbus_message_iter_get_basic(&iter, &uintval);
if (uintval > 2) {
mce_log(LL_ERR,
"Incorrect powerkey event passed to %s.%s; "
"ignoring request",
MCE_REQUEST_IF, MCE_TRIGGER_POWERKEY_EVENT_REQ);
goto EXIT;
}
break;
default:
mce_log(LL_ERR,
"Argument %d passed to %s.%s has incorrect type",
argcount,
MCE_REQUEST_IF, MCE_TRIGGER_POWERKEY_EVENT_REQ);
goto EXIT;
}
while (dbus_message_iter_next(&iter) == TRUE)
argcount++;
if (argcount > 1) {
mce_log(LL_WARN,
"Too many arguments passed to %s.%s; "
"got %d, expected %d -- ignoring extra arguments",
MCE_REQUEST_IF, MCE_TRIGGER_POWERKEY_EVENT_REQ,
argcount, 1);
}
mce_log(LL_DEBUG, "[power] button event trigger value: %d", uintval);
cancel_powerkey_timeout();
cancel_doublepress_timeout();
switch (uintval) {
default:
case 0:
/* short press */
generic_powerkey_handler(shortpressaction,
shortpresssignal);
break;
case 1:
/* long press */
handle_longpress();
break;
case 2:
/* double press */
generic_powerkey_handler(doublepressaction,
doublepresssignal);
break;
}
if (no_reply == FALSE) {
DBusMessage *reply = dbus_new_method_reply(msg);
status = dbus_send_message(reply);
} else {
status = TRUE;
}
EXIT:
return status;
}
static void
service_dispatch_message (GkdSecretService *self, DBusMessage *message)
{
DBusMessage *reply = NULL;
const gchar *caller;
ServiceClient *client;
const gchar *path;
gpointer object;
g_assert (GKD_SECRET_IS_SERVICE (self));
g_assert (message);
/* The first thing we do is try to allocate a client context */
caller = dbus_message_get_sender (message);
if (caller == NULL) {
reply = dbus_message_new_error (message, DBUS_ERROR_FAILED,
"Could not not identify calling client application");
dbus_connection_send (self->connection, reply, NULL);
dbus_message_unref (reply);
return;
}
client = g_hash_table_lookup (self->clients, caller);
if (client == NULL) {
initialize_service_client (self, message);
return; /* This function called again, when client is initialized */
}
path = dbus_message_get_path (message);
g_return_if_fail (path);
/* Dispatched to a session or prompt */
if (object_path_has_prefix (path, SECRET_SESSION_PREFIX) ||
object_path_has_prefix (path, SECRET_PROMPT_PREFIX)) {
object = g_hash_table_lookup (client->dispatch, path);
if (object == NULL)
reply = gkd_secret_error_no_such_object (message);
else
reply = gkd_secret_dispatch_message (GKD_SECRET_DISPATCH (object), message);
/* Dispatched to a collection, off it goes */
} else if (object_path_has_prefix (path, SECRET_COLLECTION_PREFIX) ||
object_path_has_prefix (path, SECRET_ALIAS_PREFIX)) {
reply = gkd_secret_objects_dispatch (self->objects, message);
/* Addressed to the service */
} else if (g_str_equal (path, SECRET_SERVICE_PATH)) {
reply = service_message_handler (self, message);
}
/* Should we send an error? */
if (!reply && dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_CALL) {
if (!dbus_message_get_no_reply (message)) {
reply = dbus_message_new_error_printf (message, DBUS_ERROR_UNKNOWN_METHOD,
"Method \"%s\" with signature \"%s\" on interface \"%s\" doesn't exist\n",
dbus_message_get_member (message),
dbus_message_get_signature (message),
dbus_message_get_interface (message));
}
}
if (reply) {
dbus_connection_send (self->connection, reply, NULL);
dbus_message_unref (reply);
}
}