static DBusHandlerResult generic_message(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct generic_data *data = user_data;
struct interface_data *iface;
const GDBusMethodTable *method;
const char *interface;
interface = dbus_message_get_interface(message);
iface = find_interface(data->interfaces, interface);
if (iface == NULL)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
for (method = iface->methods; method &&
method->name && method->function; method++) {
if (dbus_message_is_method_call(message, iface->name,
method->name) == FALSE)
continue;
if (dbus_message_has_signature(message,
method->signature) == FALSE)
continue;
if (check_privilege(connection, message, method,
iface->user_data) == TRUE)
return DBUS_HANDLER_RESULT_HANDLED;
return process_message(connection, message, method,
iface->user_data);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
DBusMessage*
hippo_dbus_handle_is_ready(HippoDBus *dbus,
DBusMessage *message)
{
HippoSettings *settings;
dbus_bool_t v_BOOLEAN;
DBusMessage *reply;
g_debug("handling IsReady()");
if (!dbus_message_has_signature(message, "")) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Expected zero arguments"));
}
settings = get_and_ref_settings(hippo_dbus_get_connection(dbus));
v_BOOLEAN = hippo_settings_get_ready(settings);
g_object_unref(settings);
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &v_BOOLEAN, DBUS_TYPE_INVALID);
return reply;
}
static DBusHandlerResult
navit_handler_func(DBusConnection *connection, DBusMessage *message, void *user_data)
{
int i;
char *path;
dbg(0,"type=%s interface=%s path=%s member=%s signature=%s\n", dbus_message_type_to_string(dbus_message_get_type(message)), dbus_message_get_interface(message), dbus_message_get_path(message), dbus_message_get_member(message), dbus_message_get_signature(message));
if (dbus_message_is_method_call (message, "org.freedesktop.DBus.Introspectable", "Introspect")) {
DBusMessage *reply;
char *navitintrospectxml = generate_navitintrospectxml(dbus_message_get_path(message));
dbg(0,"Introspect %s:Result:%s\n",dbus_message_get_path(message), navitintrospectxml);
if (navitintrospectxml) {
reply = dbus_message_new_method_return(message);
dbus_message_append_args(reply, DBUS_TYPE_STRING, &navitintrospectxml, DBUS_TYPE_INVALID);
dbus_connection_send (connection, reply, NULL);
dbus_message_unref (reply);
g_free(navitintrospectxml);
return DBUS_HANDLER_RESULT_HANDLED;
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
for (i = 0 ; i < sizeof(dbus_methods)/sizeof(struct dbus_method) ; i++) {
path=g_strdup_printf("%s%s", service_name, dbus_methods[i].path);
if (dbus_message_is_method_call(message, path, dbus_methods[i].method) &&
dbus_message_has_signature(message, dbus_methods[i].signature)) {
g_free(path);
return dbus_methods[i].func(connection, message);
}
g_free(path);
}
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
static DBusMessage*
service_method_open_session (GkdSecretService *self, DBusMessage *message)
{
GkdSecretSession *session;
ServiceClient *client;
DBusMessage *reply = NULL;
const gchar *caller;
const gchar *path;
if (!dbus_message_has_signature (message, "sv"))
return NULL;
caller = dbus_message_get_sender (message);
/* Now we can create a session with this information */
session = gkd_secret_session_new (self, caller);
reply = gkd_secret_session_handle_open (session, message);
if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_METHOD_RETURN) {
/* Take ownership of the session */
client = g_hash_table_lookup (self->clients, caller);
g_return_val_if_fail (client, NULL);
path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (session));
g_return_val_if_fail (!g_hash_table_lookup (client->sessions, path), NULL);
g_hash_table_replace (client->sessions, (gpointer)path, session);
} else {
g_object_unref (session);
}
return reply;
}
static gboolean connection_added(DBusConnection *conn, DBusMessage *message,
void *user_data)
{
DBusMessageIter iter, properties;
const char *path;
const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING
DBUS_TYPE_ARRAY_AS_STRING
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
if (dbus_message_has_signature(message, signature) == FALSE) {
connman_error("vpn ConnectionAdded signature \"%s\" does not "
"match expected \"%s\"",
dbus_message_get_signature(message), signature);
return TRUE;
}
DBG("");
if (dbus_message_iter_init(message, &iter) == FALSE)
return TRUE;
dbus_message_iter_get_basic(&iter, &path);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &properties);
add_connection(path, &properties, user_data);
return TRUE;
}
static void get_connection_unix_user_reply(DBusPendingCall *call,
void *user_data)
{
struct callback_data *data = user_data;
connman_dbus_get_connection_unix_user_cb_t cb = data->cb;
DBusMessageIter iter;
DBusMessage *reply;
int err = 0;
unsigned int uid;
reply = dbus_pending_call_steal_reply(call);
if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
DBG("Failed to retrieve UID");
err = -EIO;
goto done;
}
if (!dbus_message_has_signature(reply, "u")) {
DBG("Message signature is wrong");
err = -EINVAL;
goto done;
}
dbus_message_iter_init(reply, &iter);
dbus_message_iter_get_basic(&iter, &uid);
done:
(*cb)(uid, data->user_data, err);
dbus_message_unref(reply);
dbus_pending_call_unref(call);
}
static void selinux_get_context_reply(DBusPendingCall *call, void *user_data)
{
struct callback_data *data = user_data;
connman_dbus_get_context_cb_t cb = data->cb;
DBusMessage *reply;
unsigned char *context = NULL;
int err = 0;
reply = dbus_pending_call_steal_reply(call);
if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
DBG("Failed to retrieve SELinux context");
err = -EIO;
goto done;
}
if (!dbus_message_has_signature(reply, "ay")) {
DBG("Message signature is wrong");
err = -EINVAL;
goto done;
}
context = parse_context(reply);
done:
(*cb)(context, data->user_data, err);
g_free(context);
dbus_message_unref(reply);
dbus_pending_call_unref(call);
}
CVariant CDBusUtil::GetVariant(const char *destination, const char *object, const char *interface, const char *property)
{
//dbus-send --system --print-reply --dest=destination object org.freedesktop.DBus.Properties.Get string:interface string:property
CDBusMessage message(destination, object, "org.freedesktop.DBus.Properties", "Get");
CVariant result;
if (message.AppendArgument(interface) && message.AppendArgument(property))
{
DBusMessage *reply = message.SendSystem();
if (reply)
{
DBusMessageIter iter;
if (dbus_message_iter_init(reply, &iter))
{
if (!dbus_message_has_signature(reply, "v"))
CLog::Log(LOGERROR, "DBus: wrong signature on Get - should be \"v\" but was %s", dbus_message_iter_get_signature(&iter));
else
result = ParseVariant(&iter);
}
}
}
else
CLog::Log(LOGERROR, "DBus: append arguments failed");
return result;
}
static DBusMessage*
service_method_create_collection (GkdSecretService *self, DBusMessage *message)
{
DBusMessageIter iter, array;
GckAttributes *attrs;
GkdSecretCreate *create;
DBusMessage *reply;
const gchar *path;
const gchar *alias;
const char *caller;
const gchar *coll;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "a{sv}s"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
attrs = gck_attributes_new ();
dbus_message_iter_recurse (&iter, &array);
if (!gkd_secret_property_parse_all (&array, SECRET_COLLECTION_INTERFACE, attrs)) {
gck_attributes_unref (attrs);
return dbus_message_new_error_printf (message, DBUS_ERROR_INVALID_ARGS,
"Invalid properties");
}
if (!dbus_message_iter_next (&iter))
g_return_val_if_reached (NULL);
dbus_message_iter_get_basic (&iter, &alias);
/* Empty alias is no alias */
if (alias) {
if (!alias[0]) {
alias = NULL;
} else if (!g_str_equal (alias, "default")) {
gck_attributes_unref (attrs);
return dbus_message_new_error (message, DBUS_ERROR_NOT_SUPPORTED,
"Only the 'default' alias is supported");
}
}
gck_attributes_add_boolean (attrs, CKA_TOKEN, TRUE);
/* Create the prompt object, for the password */
caller = dbus_message_get_sender (message);
create = gkd_secret_create_new (self, caller, attrs, alias);
gck_attributes_unref (attrs);
path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (create));
gkd_secret_service_publish_dispatch (self, caller,
GKD_SECRET_DISPATCH (create));
coll = "/";
reply = dbus_message_new_method_return (message);
dbus_message_append_args (reply,
DBUS_TYPE_OBJECT_PATH, &coll,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
g_object_unref (create);
return reply;
}
static DBusMessage*
service_method_change_with_master_password (GkdSecretService *self, DBusMessage *message)
{
DBusError derr = DBUS_ERROR_INIT;
GkdSecretSecret *original, *master;
GckObject *collection;
DBusMessageIter iter;
DBusMessage *reply;
GError *error = NULL;
const gchar *path;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "o(oayays)(oayays)"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
dbus_message_iter_get_basic (&iter, &path);
dbus_message_iter_next (&iter);
original = gkd_secret_secret_parse (self, message, &iter, &derr);
if (original == NULL)
return gkd_secret_error_to_reply (message, &derr);
dbus_message_iter_next (&iter);
master = gkd_secret_secret_parse (self, message, &iter, &derr);
if (master == NULL) {
gkd_secret_secret_free (original);
return gkd_secret_error_to_reply (message, &derr);
}
/* Make sure we have such a collection */
collection = gkd_secret_objects_lookup_collection (self->objects,
dbus_message_get_sender (message),
path);
/* No such collection */
if (collection == NULL)
reply = dbus_message_new_error (message, SECRET_ERROR_NO_SUCH_OBJECT,
"The collection does not exist");
/* Success */
else if (gkd_secret_change_with_secrets (collection, NULL, original, master, &error))
reply = dbus_message_new_method_return (message);
/* Failure */
else
reply = gkd_secret_propagate_error (message, "Couldn't change collection password", error);
gkd_secret_secret_free (original);
gkd_secret_secret_free (master);
if (collection)
g_object_unref (collection);
return reply;
}
dbus_bool_t
bus_driver_send_service_owner_changed (const char *service_name,
const char *old_owner,
const char *new_owner,
BusTransaction *transaction,
DBusError *error)
{
DBusMessage *message;
dbus_bool_t retval;
const char *null_service;
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
null_service = "";
_dbus_verbose ("sending name owner changed: %s [%s -> %s]\n",
service_name,
old_owner ? old_owner : null_service,
new_owner ? new_owner : null_service);
message = dbus_message_new_signal (DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"NameOwnerChanged");
if (message == NULL)
{
BUS_SET_OOM (error);
return FALSE;
}
if (!dbus_message_set_sender (message, DBUS_SERVICE_DBUS))
goto oom;
if (!dbus_message_append_args (message,
DBUS_TYPE_STRING, &service_name,
DBUS_TYPE_STRING, old_owner ? &old_owner : &null_service,
DBUS_TYPE_STRING, new_owner ? &new_owner : &null_service,
DBUS_TYPE_INVALID))
goto oom;
_dbus_assert (dbus_message_has_signature (message, "sss"));
retval = bus_dispatch_matches (transaction, NULL, NULL, message, error);
dbus_message_unref (message);
return retval;
oom:
dbus_message_unref (message);
BUS_SET_OOM (error);
return FALSE;
}
long GMNotifyDaemon::onSignal(FXObject*,FXSelector,void*ptr){
DBusMessage * msg = static_cast<DBusMessage*>(ptr);
FXuint id,reason;
FXchar * action;
if (dbus_message_is_signal(msg,GALAGO_NOTIFY_INTERFACE,"NotificationClosed")){
if ((dbus_message_has_signature(msg,"u") && dbus_message_get_args(msg,NULL,DBUS_TYPE_UINT32,&id,DBUS_TYPE_INVALID)) ||
(dbus_message_has_signature(msg,"uu") && dbus_message_get_args(msg,NULL,DBUS_TYPE_UINT32,&id,DBUS_TYPE_UINT32,&reason,DBUS_TYPE_INVALID))) {
if (id==msgid) {
msgid=0;
}
}
return 1;
}
else if (dbus_message_is_signal(msg,GALAGO_NOTIFY_INTERFACE,"ActionInvoked")){
if (dbus_message_has_signature(msg,"us") && dbus_message_get_args(msg,NULL,DBUS_TYPE_UINT32,&id,DBUS_TYPE_STRING,&action,DBUS_TYPE_INVALID)) {
if (compare(action,"media-skip-backward")==0) {
GMPlayerManager::instance()->cmd_prev();
}
else if (compare(action,"media-skip-forward")==0) {
GMPlayerManager::instance()->cmd_next();
}
else if (compare(action,"media-playback-pause")==0) {
GMPlayerManager::instance()->cmd_pause();
}
else if (compare(action,"media-playback-start")==0) {
GMPlayerManager::instance()->cmd_play();
}
else if (compare(action,"media-playback-stop")==0) {
GMPlayerManager::instance()->cmd_stop();
}
else {
GM_DEBUG_PRINT("unhandled action: %s\n",action);
}
return 1;
}
}
return 0;
}
static DBusMessage*
service_method_create_with_master_password (GkdSecretService *self, DBusMessage *message)
{
GckBuilder builder = GCK_BUILDER_INIT;
DBusError derr = DBUS_ERROR_INIT;
DBusMessageIter iter, array;
DBusMessage *reply = NULL;
GkdSecretSecret *secret = NULL;
GckAttributes *attrs = NULL;
GError *error = NULL;
gchar *path;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "a{sv}(oayays)"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
dbus_message_iter_recurse (&iter, &array);
if (!gkd_secret_property_parse_all (&array, SECRET_COLLECTION_INTERFACE, &builder)) {
gck_builder_clear (&builder);
return dbus_message_new_error (message, DBUS_ERROR_INVALID_ARGS,
"Invalid properties argument");
}
dbus_message_iter_next (&iter);
secret = gkd_secret_secret_parse (self, message, &iter, &derr);
if (secret == NULL) {
gck_builder_clear (&builder);
return gkd_secret_error_to_reply (message, &derr);
}
gck_builder_add_boolean (&builder, CKA_TOKEN, TRUE);
attrs = gck_attributes_ref_sink (gck_builder_end (&builder));
path = gkd_secret_create_with_secret (attrs, secret, &error);
gck_attributes_unref (attrs);
gkd_secret_secret_free (secret);
if (path == NULL)
return gkd_secret_propagate_error (message, "Couldn't create collection", error);
/* Notify the callers that a collection was created */
gkd_secret_service_emit_collection_created (self, path);
reply = dbus_message_new_method_return (message);
dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
g_free (path);
return reply;
}
CVariant CDBusUtil::GetAll(const char *destination, const char *object, const char *interface)
{
CDBusMessage message(destination, object, "org.freedesktop.DBus.Properties", "GetAll");
CVariant properties;
message.AppendArgument(interface);
DBusMessage *reply = message.SendSystem();
if (reply)
{
DBusMessageIter iter;
if (dbus_message_iter_init(reply, &iter))
{
if (!dbus_message_has_signature(reply, "a{sv}"))
CLog::Log(LOGERROR, "DBus: wrong signature on GetAll - should be \"a{sv}\" but was %s", dbus_message_iter_get_signature(&iter));
else
{
do
{
DBusMessageIter sub;
dbus_message_iter_recurse(&iter, &sub);
do
{
DBusMessageIter dict;
dbus_message_iter_recurse(&sub, &dict);
do
{
const char * key = NULL;
dbus_message_iter_get_basic(&dict, &key);
if (!dbus_message_iter_next(&dict))
break;
CVariant value = ParseVariant(&dict);
if (!value.isNull())
properties[key] = value;
} while (dbus_message_iter_next(&dict));
} while (dbus_message_iter_next(&sub));
} while (dbus_message_iter_next(&iter));
}
}
}
return properties;
}
static DBusMessage*
service_method_create_collection (GkdSecretService *self, DBusMessage *message)
{
DBusMessageIter iter, array;
GP11Attributes *attrs;
GkdSecretCreate *create;
ServiceClient *client;
DBusMessage *reply;
const gchar *path;
const char *caller;
const gchar *coll;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "a{sv}"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
attrs = gp11_attributes_new ();
dbus_message_iter_recurse (&iter, &array);
if (!gkd_secret_property_parse_all (&array, attrs)) {
gp11_attributes_unref (attrs);
return dbus_message_new_error_printf (message, DBUS_ERROR_INVALID_ARGS,
"Invalid properties");
}
gp11_attributes_add_boolean (attrs, CKA_TOKEN, TRUE);
/* Create the prompt object, for the password */
caller = dbus_message_get_sender (message);
create = gkd_secret_create_new (self, caller, attrs);
gp11_attributes_unref (attrs);
path = gkd_secret_dispatch_get_object_path (GKD_SECRET_DISPATCH (create));
client = g_hash_table_lookup (self->clients, caller);
g_return_val_if_fail (client, NULL);
g_hash_table_replace (client->prompts, (gpointer)path, create);
coll = "/";
reply = dbus_message_new_method_return (message);
dbus_message_append_args (reply,
DBUS_TYPE_OBJECT_PATH, &coll,
DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *interface_version(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
dbus_uint32_t version = 0;
if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
return invalid_args(msg);
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
dbus_message_append_args(reply, DBUS_TYPE_UINT32, &version,
DBUS_TYPE_INVALID);
return reply;
}
static gboolean connection_removed(DBusConnection *conn, DBusMessage *message,
void *user_data)
{
const char *path;
const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
if (dbus_message_has_signature(message, signature) == FALSE) {
connman_error("vpn removed signature \"%s\" does not match "
"expected \"%s\"",
dbus_message_get_signature(message), signature);
return TRUE;
}
dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
remove_connection(conn, path);
return TRUE;
}
static dbus_bool_t
bus_driver_send_welcome_message (DBusConnection *connection,
DBusMessage *hello_message,
BusTransaction *transaction,
DBusError *error)
{
DBusMessage *welcome;
const char *name;
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
name = bus_connection_get_name (connection);
_dbus_assert (name != NULL);
welcome = dbus_message_new_method_return (hello_message);
if (welcome == NULL)
{
BUS_SET_OOM (error);
return FALSE;
}
if (!dbus_message_append_args (welcome,
DBUS_TYPE_STRING, &name,
DBUS_TYPE_INVALID))
{
dbus_message_unref (welcome);
BUS_SET_OOM (error);
return FALSE;
}
_dbus_assert (dbus_message_has_signature (welcome, DBUS_TYPE_STRING_AS_STRING));
if (!bus_transaction_send_from_driver (transaction, connection, welcome))
{
dbus_message_unref (welcome);
BUS_SET_OOM (error);
return FALSE;
}
else
{
dbus_message_unref (welcome);
return TRUE;
}
}
static bool check_reply_has_dict(DBusMessage *reply)
{
const char *signature = DBUS_TYPE_ARRAY_AS_STRING
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
if (dbus_message_has_signature(reply, signature))
return true;
connman_warn("Reply %s to %s from %s has wrong signature %s",
signature,
dbus_message_get_interface(reply),
dbus_message_get_sender(reply),
dbus_message_get_signature(reply));
return false;
}
static DBusMessage*
service_method_create_with_master_password (GkdSecretService *self, DBusMessage *message)
{
DBusError derr = DBUS_ERROR_INIT;
DBusMessageIter iter, array;
DBusMessage *reply = NULL;
GkdSecretSecret *secret = NULL;
GckAttributes *attrs = NULL;
gchar *path;
/* Parse the incoming message */
if (!dbus_message_has_signature (message, "a{sv}(oayays)"))
return NULL;
if (!dbus_message_iter_init (message, &iter))
g_return_val_if_reached (NULL);
attrs = gck_attributes_new ();
dbus_message_iter_recurse (&iter, &array);
if (!gkd_secret_property_parse_all (&array, SECRET_COLLECTION_INTERFACE, attrs)) {
gck_attributes_unref (attrs);
return dbus_message_new_error (message, DBUS_ERROR_INVALID_ARGS,
"Invalid properties argument");
}
dbus_message_iter_next (&iter);
secret = gkd_secret_secret_parse (self, message, &iter, &derr);
if (secret == NULL) {
gck_attributes_unref (attrs);
return gkd_secret_error_to_reply (message, &derr);
}
gck_attributes_add_boolean (attrs, CKA_TOKEN, TRUE);
path = gkd_secret_create_with_secret (attrs, secret, &derr);
gck_attributes_unref (attrs);
gkd_secret_secret_free (secret);
if (path == NULL)
return gkd_secret_error_to_reply (message, &derr);
reply = dbus_message_new_method_return (message);
dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
g_free (path);
return reply;
}
static void get_modems_reply(DBusPendingCall *call, void *user_data)
{
DBusConnection *conn = user_data;
DBusMessage *reply = dbus_pending_call_steal_reply(call);
DBusMessageIter iter, list;
DBusError err;
dbus_error_init(&err);
if (dbus_set_error_from_message(&err, reply) == TRUE) {
g_printerr("%s: %s\n", err.name, err.message);
dbus_error_free(&err);
goto done;
}
if (dbus_message_has_signature(reply, "a(oa{sv})") == FALSE)
goto done;
if (dbus_message_iter_init(reply, &iter) == FALSE)
goto done;
dbus_message_iter_recurse(&iter, &list);
while (dbus_message_iter_get_arg_type(&list) == DBUS_TYPE_STRUCT) {
DBusMessageIter entry, dict;
const char *path;
dbus_message_iter_recurse(&list, &entry);
dbus_message_iter_get_basic(&entry, &path);
dbus_message_iter_next(&entry);
dbus_message_iter_recurse(&entry, &dict);
create_modem(conn, path, &entry);
dbus_message_iter_next(&list);
}
done:
dbus_message_unref(reply);
}
static int check_authorization(DBusConnection *conn)
{
DBusMessage *msg, *reply;
DBusMessageIter iter;
DBusError err;
msg = dbus_message_new_method_call(AUTHORITY_DBUS, AUTHORITY_PATH,
AUTHORITY_INTF, "CheckAuthorization");
if (!msg) {
fprintf(stderr, "Can't allocate new method call\n");
return -ENOMEM;
}
dbus_message_iter_init_append(msg, &iter);
add_arguments(conn, &iter);
dbus_error_init(&err);
reply = dbus_connection_send_with_reply_and_block(conn, msg, -1, &err);
dbus_message_unref(msg);
if (!reply) {
if (dbus_error_is_set(&err)) {
fprintf(stderr, "%s\n", err.message);
dbus_error_free(&err);
} else
fprintf(stderr, "Can't check authorization\n");
return -EIO;
}
if (dbus_message_has_signature(reply, "(bba{ss})") == TRUE) {
dbus_message_iter_init(reply, &iter);
print_arguments(&iter);
}
dbus_message_unref(reply);
return 0;
}
static DBusMessage*
service_method_open_session (GkdSecretService *self, DBusMessage *message)
{
GkdSecretSession *session;
DBusMessage *reply = NULL;
const gchar *caller;
if (!dbus_message_has_signature (message, "sv"))
return NULL;
caller = dbus_message_get_sender (message);
/* Now we can create a session with this information */
session = gkd_secret_session_new (self, caller);
reply = gkd_secret_session_handle_open (session, message);
if (dbus_message_get_type (reply) == DBUS_MESSAGE_TYPE_METHOD_RETURN)
gkd_secret_service_publish_dispatch (self, caller,
GKD_SECRET_DISPATCH (session));
g_object_unref (session);
return reply;
}
static DBusMessage *old_default_adapter(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
char path[MAX_PATH_LENGTH], *path_ptr = path;
if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
return invalid_args(msg);
if (default_adapter_id < 0)
return no_such_adapter(msg);
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
snprintf(path, sizeof(path), "%s/hci%d", BASE_PATH, default_adapter_id);
dbus_message_append_args(reply, DBUS_TYPE_STRING, &path_ptr,
DBUS_TYPE_INVALID);
return reply;
}
void *
unmarshal_string_list(DBusMessage *msg, DBusError *err)
{
E_Ukit_String_List_Return *ret = NULL;
DBusMessageIter iter, sub;
char *tmp;
/* ao = array of object strings */
if (!dbus_message_has_signature(msg, "ao"))
{
dbus_set_error(err, DBUS_ERROR_INVALID_SIGNATURE, "");
return NULL;
}
ret = calloc(1, sizeof(E_Ukit_String_List_Return));
if (!ret)
{
dbus_set_error(err, DBUS_ERROR_NO_MEMORY, "");
return NULL;
}
ret->strings = NULL;
dbus_message_iter_init(msg, &iter);
dbus_message_iter_recurse(&iter, &sub);
while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID)
{
char *dev = NULL;
dbus_message_iter_get_basic(&sub, &dev);
tmp = (char*)eina_stringshare_add(dev);
if (dev) ret->strings = eina_list_append(ret->strings, tmp);
dbus_message_iter_next(&sub);
}
return ret;
}
static DBusMessage *introspect(DBusConnection *connection,
DBusMessage *message, void *user_data)
{
struct generic_data *data = user_data;
DBusMessage *reply;
if (!dbus_message_has_signature(message, DBUS_TYPE_INVALID_AS_STRING)) {
error("Unexpected signature to introspect call");
return NULL;
}
if (data->introspect == NULL)
generate_introspection_xml(connection, data,
dbus_message_get_path(message));
reply = dbus_message_new_method_return(message);
if (reply == NULL)
return NULL;
dbus_message_append_args(reply, DBUS_TYPE_STRING, &data->introspect,
DBUS_TYPE_INVALID);
return reply;
}
static DBusMessage *list_services(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter array_iter;
if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
return invalid_args(msg);
reply = dbus_message_new_method_return(msg);
if (!reply)
return NULL;
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING_AS_STRING, &array_iter);
append_available_services(&array_iter);
dbus_message_iter_close_container(&iter, &array_iter);
return reply;
}
/**
* @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);
}
static DBusMessage *old_list_adapters(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessageIter iter;
DBusMessageIter array_iter;
DBusMessage *reply;
struct hci_dev_list_req *dl;
struct hci_dev_req *dr;
int i, sk;
if (!dbus_message_has_signature(msg, DBUS_TYPE_INVALID_AS_STRING))
return invalid_args(msg);
sk = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
if (sk < 0)
return failed_strerror(msg, errno);
dl = g_malloc0(HCI_MAX_DEV * sizeof(*dr) + sizeof(*dl));
dl->dev_num = HCI_MAX_DEV;
dr = dl->dev_req;
if (ioctl(sk, HCIGETDEVLIST, dl) < 0) {
int err = errno;
close(sk);
g_free(dl);
return failed_strerror(msg, err);
}
dr = dl->dev_req;
reply = dbus_message_new_method_return(msg);
if (!reply) {
close(sk);
g_free(dl);
return NULL;
}
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
DBUS_TYPE_STRING_AS_STRING, &array_iter);
for (i = 0; i < dl->dev_num; i++, dr++) {
char path[MAX_PATH_LENGTH], *path_ptr = path;
struct hci_dev_info di;
if (hci_devinfo(dr->dev_id, &di) < 0)
continue;
if (hci_test_bit(HCI_RAW, &di.flags))
continue;
snprintf(path, sizeof(path), "%s/%s", BASE_PATH, di.name);
dbus_message_iter_append_basic(&array_iter,
DBUS_TYPE_STRING, &path_ptr);
}
dbus_message_iter_close_container(&iter, &array_iter);
g_free(dl);
close(sk);
return reply;
}
/**
* @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);
}
