int bridge_request_call_dbus_json(bridge_request_t *self, DBusMessage *in_dbus)
{
DBusMessageIter it;
DBusError err;
struct json_object *result = 0;
int ret = 0;
if (dbus_message_get_type(in_dbus) == DBUS_MESSAGE_TYPE_ERROR) {
dbus_error_init(&err);
(void)dbus_set_error_from_message(&err, in_dbus);
bridge_request_error(self, err.message ? err.message : err.name);
dbus_error_free(&err);
ret = EINVAL;
goto finish;
}
if (dbus_message_iter_init(in_dbus, &it)) {
if ((ret = bridge_request_json_params(self, &it, &result, dbus_message_iter_has_next(&it))) != 0)
goto finish;
}
if ((ret = bridge_request_send_response(self, 0, result)) != 0) {
bridge_request_error(self, "Out of memory.");
}
finish:
if (result)
json_object_put(result);
dbus_message_unref(in_dbus);
FCGX_Finish_r(&self->request);
self->next = self->bridge->head;
self->bridge->head = self;
return ret;
}
static void list_service_array(DBusMessageIter *iter)
{
DBusMessageIter array, dict;
char *path = NULL;
while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRUCT) {
dbus_message_iter_recurse(iter, &array);
if (dbus_message_iter_get_arg_type(&array)
!= DBUS_TYPE_OBJECT_PATH)
return;
dbus_message_iter_get_basic(&array, &path);
dbus_message_iter_next(&array);
if (dbus_message_iter_get_arg_type(&array)
== DBUS_TYPE_ARRAY) {
dbus_message_iter_recurse(&array, &dict);
print_service(path, &dict);
}
if (dbus_message_iter_has_next(iter))
fprintf(stdout, "\n");
dbus_message_iter_next(iter);
}
}
static DBusHandlerResult
request_navit_zoom(DBusConnection *connection, DBusMessage *message)
{
int factor;
struct point p;
struct navit *navit;
DBusMessageIter iter;
navit = object_get_from_message(message, "navit");
if (! navit)
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
dbus_message_iter_init(message, &iter);
dbg(0,"%s\n", dbus_message_iter_get_signature(&iter));
dbus_message_iter_get_basic(&iter, &factor);
if (dbus_message_iter_has_next(&iter))
{
dbus_message_iter_next(&iter);
if (!point_get_from_message(message, &iter, &p))
return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
}
if (factor > 1)
navit_zoom_in(navit, factor, &p);
else if (factor < -1)
navit_zoom_out(navit, 0-factor, &p);
return empty_reply(connection, message);
}
static DBusHandlerResult
skype_notify_handler(DBusConnection *connection, DBusMessage *message, gpointer user_data)
{
DBusMessageIter iterator;
gchar *message_temp;
DBusMessage *temp_message;
temp_message = dbus_message_ref(message);
dbus_message_iter_init(temp_message, &iterator);
if (dbus_message_iter_get_arg_type(&iterator) != DBUS_TYPE_STRING)
{
dbus_message_unref(message);
return FALSE;
}
do
{
dbus_message_iter_get_basic(&iterator, &message_temp);
skype_message_received(g_strdup(message_temp));
} while(dbus_message_iter_has_next(&iterator) && dbus_message_iter_next(&iterator));
dbus_message_unref(message);
return DBUS_HANDLER_RESULT_HANDLED;
}
static gboolean
question_demarshal_in (DBusMessageIter *iter,
gpointer *in, gsize *in_size,
gpointer *out, gsize *out_size)
{
MateVFSModuleCallbackQuestionIn *question_in;
DBusMessageIter array_iter;
int cnt;
question_in = *in = g_new0 (MateVFSModuleCallbackQuestionIn, 1);
*in_size = sizeof (MateVFSModuleCallbackQuestionIn);
*out = g_new0 (MateVFSModuleCallbackQuestionOut, 1);
*out_size = sizeof (MateVFSModuleCallbackQuestionOut);
question_in->primary_message = utils_get_string_or_null (iter, FALSE);
dbus_message_iter_next (iter);
question_in->secondary_message = utils_get_string_or_null (iter, FALSE);
dbus_message_iter_next (iter);
if (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_ARRAY) {
dbus_message_iter_recurse (iter, &array_iter);
cnt = 0;
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_STRING) {
cnt++;
if (!dbus_message_iter_has_next (&array_iter)) {
break;
}
dbus_message_iter_next (&array_iter);
}
question_in->choices = g_new (char *, cnt + 1);
dbus_message_iter_recurse (iter, &array_iter);
cnt = 0;
while (dbus_message_iter_get_arg_type (&array_iter) == DBUS_TYPE_STRING) {
question_in->choices[cnt++] = utils_get_string_or_null (&array_iter, FALSE);
if (!dbus_message_iter_has_next (&array_iter)) {
break;
}
dbus_message_iter_next (&array_iter);
}
question_in->choices[cnt++] = NULL;
}
static bool properties_to_info(DBusMessage* properties, SynceInfo* info)
{
DBusMessageIter iter;
DBusMessageIter iter_dict;
dbus_message_iter_init(properties, &iter);
for (dbus_message_iter_init_dict_iterator(&iter, &iter_dict);
;
dbus_message_iter_next(&iter_dict))
{
char* str_value = NULL;
char* key = dbus_message_iter_get_dict_key(&iter_dict);
int type = dbus_message_iter_get_arg_type(&iter_dict);
int int_value;
synce_debug("Key = %s", key);
if (!key)
continue;
switch (type)
{
case DBUS_TYPE_STRING:
str_value = dbus_message_iter_get_string(&iter_dict);
if (STR_EQUAL(key, "address"))
info->ip = STRDUP(str_value);
else if (STR_EQUAL(key, "password"))
info->password = STRDUP(str_value);
/* TODO: handle more string properties */
dbus_free(str_value);
break;
case DBUS_TYPE_INT32:
int_value = dbus_message_iter_get_int32(&iter_dict);
if (STR_EQUAL(key, "key"))
info->key = int_value;
/* TODO: handle more int32 properties */
break;
}
dbus_free(key);
if (!dbus_message_iter_has_next(&iter_dict))
break;
}
/* Fake dccm PID! */
info->dccm_pid = getpid();
return info->ip != NULL;
}
void qFetchUInt64KeyMapEntry(QDBusDataMap<Q_UINT64>& map, DBusMessageIter* it)
{
DBusMessageIter itemIter;
dbus_message_iter_recurse(it, &itemIter);
Q_ASSERT(dbus_message_iter_has_next(&itemIter));
Q_UINT64 key = qFetchParameter(&itemIter).toUInt64();
dbus_message_iter_next(&itemIter);
map.insert(key, qFetchParameter(&itemIter));
}
void qFetchStringKeyMapEntry(QDBusDataMap<QString>& map, DBusMessageIter* it)
{
DBusMessageIter itemIter;
dbus_message_iter_recurse(it, &itemIter);
Q_ASSERT(dbus_message_iter_has_next(&itemIter));
QString key = qFetchParameter(&itemIter).toString();
dbus_message_iter_next(&itemIter);
map.insert(key, qFetchParameter(&itemIter));
}
static QList<QVariant>
qml_list_from_dbus_message(DBusMessage *msg)
{
DBusMessageIter iter;
QVariantList r;
dbus_message_iter_init(msg, &iter);
for (;;) {
r.append(qml_from_dbus_iter(&iter));
if (!dbus_message_iter_has_next(&iter))
break;
dbus_message_iter_next(&iter);
}
// qDebug() << "Result" << r;
return r;
}
static DBusMessage*
handle_update (void *object,
DBusMessage *message,
DBusError *error)
{
DDMDataModel *model;
const char *method_uri;
GHashTable *params = NULL;
DBusMessageIter iter;
model = hippo_app_get_data_model(hippo_get_app());
dbus_message_iter_init (message, &iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("First argument should be a string (method_uri)"));
}
dbus_message_iter_get_basic(&iter, &method_uri);
dbus_message_iter_next (&iter);
params = read_params_dictionary(&iter);
if (params == NULL)
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Second argument should be a dictionary string=>string (params)"));
if (dbus_message_iter_has_next(&iter))
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Too many arguments"));
if (!hippo_dbus_model_client_do_update(model,
hippo_dbus_get_connection(hippo_app_get_dbus(hippo_get_app())),
message, method_uri, params)) {
/* We've already validated most arguments, so don't worry too much about getting a
* good error message if something goes wrong at this point
*/
return dbus_message_new_error(message,
DBUS_ERROR_FAILED,
_("Couldn't send update"));
}
g_hash_table_destroy(params);
return NULL;
}
static DBusMessage*
handle_forget (void *object,
DBusMessage *message,
DBusError *error)
{
const char *notification_path;
const char *resource_id;
DBusMessageIter iter;
dbus_message_iter_init (message, &iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("First argument should be an object path (notification_path)"));
}
dbus_message_iter_get_basic(&iter, ¬ification_path);
dbus_message_iter_next (&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Second argument should be a string (resource_id)"));
}
dbus_message_iter_get_basic(&iter, &resource_id);
dbus_message_iter_next (&iter);
if (dbus_message_iter_has_next(&iter))
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Too many arguments"));
/* FIXME: Do the forget; change the NULL return to an ACK if we aren't doing something async */
return NULL;
}
static QVariantList
qml_from_dbus_iter(DBusMessageIter *iter)
{
QVariantList r;
int arg=dbus_message_iter_get_arg_type(iter);
switch(arg) {
case DBUS_TYPE_ARRAY:
{
DBusMessageIter sub;
QVariantList a;
dbus_message_iter_recurse(iter, &sub);
const char *type="array";
for (;;) {
if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_DICT_ENTRY)
type="map";
a.append(qml_from_dbus_iter(&sub));
if (!dbus_message_iter_has_next(&sub))
break;
dbus_message_iter_next(&sub);
}
r.append(type);
r.append(QVariant(a));
}
break;
case DBUS_TYPE_DICT_ENTRY:
{
DBusMessageIter sub;
dbus_message_iter_recurse(iter, &sub);
for (;;) {
r.append(qml_from_dbus_iter(&sub));
if (!dbus_message_iter_has_next(&sub))
break;
dbus_message_iter_next(&sub);
}
}
break;
case DBUS_TYPE_VARIANT:
{
DBusMessageIter sub;
QVariantList a;
dbus_message_iter_recurse(iter, &sub);
for (;;) {
a.append(qml_from_dbus_iter(&sub));
if (!dbus_message_iter_has_next(&sub))
break;
dbus_message_iter_next(&sub);
}
r.append("variant");
r.append(QVariant(a));
}
break;
break;
case DBUS_TYPE_STRUCT:
{
DBusMessageIter sub;
QVariantList a;
dbus_message_iter_recurse(iter, &sub);
for (;;) {
a.append(qml_from_dbus_iter(&sub));
if (!dbus_message_iter_has_next(&sub))
break;
dbus_message_iter_next(&sub);
}
r.append("structure");
r.append(QVariant(a));
}
break;
case DBUS_TYPE_BOOLEAN:
{
dbus_bool_t v;
r.append("boolean");
dbus_message_iter_get_basic(iter, &v);
r.append(v);
}
break;
case DBUS_TYPE_INT16:
{
dbus_int16_t v;
r.append("int16");
dbus_message_iter_get_basic(iter, &v);
r.append(v);
}
break;
case DBUS_TYPE_INT32:
{
dbus_int32_t v;
r.append("int32");
dbus_message_iter_get_basic(iter, &v);
r.append(v);
}
break;
case DBUS_TYPE_BYTE:
{
unsigned char v;
r.append("uint8");
dbus_message_iter_get_basic(iter, &v);
r.append(v);
}
break;
case DBUS_TYPE_UINT32:
{
dbus_uint32_t v;
r.append("uint32");
dbus_message_iter_get_basic(iter, &v);
r.append(v);
}
break;
case DBUS_TYPE_UINT64:
{
qulonglong v;
r.append("uint64");
dbus_message_iter_get_basic(iter, &v);
r.append(v);
}
break;
case DBUS_TYPE_UINT16:
{
dbus_uint16_t v;
r.append("uint16");
dbus_message_iter_get_basic(iter, &v);
r.append(v);
}
break;
case DBUS_TYPE_DOUBLE:
{
double v;
r.append("double");
dbus_message_iter_get_basic(iter, &v);
r.append(v);
}
break;
case DBUS_TYPE_STRING:
{
char *v;
r.append("string");
dbus_message_iter_get_basic(iter, &v);
r.append(QString::fromUtf8(v));
}
break;
case DBUS_TYPE_INVALID:
break;
default:
fprintf(stderr,"Unsupported Arg %d(%c)\n",arg,(char)arg);
}
return r;
}
static char*
string_value_from_array(DBusMessageIter *array_iter,
int value_type)
{
GString *json_array;
/* We store arrays as JSON lists */
json_array = g_string_new("[");
while (dbus_message_iter_get_arg_type(array_iter) != DBUS_TYPE_INVALID) {
switch (value_type) {
case DBUS_TYPE_STRING:
{
const char *v_STRING;
char *s;
dbus_message_iter_get_basic(array_iter, &v_STRING);
s = json_string_escape(v_STRING);
g_string_append(json_array, s);
g_free(s);
}
break;
case DBUS_TYPE_INT32:
{
dbus_int32_t v_INT32;
dbus_message_iter_get_basic(array_iter, &v_INT32);
g_string_append_printf(json_array, "%d", v_INT32);
}
break;
case DBUS_TYPE_BOOLEAN:
{
dbus_bool_t v_BOOLEAN;
dbus_message_iter_get_basic(array_iter, &v_BOOLEAN);
g_string_append(json_array, v_BOOLEAN ? "true" : "false");
}
break;
case DBUS_TYPE_DOUBLE:
{
double v_DOUBLE;
char buf[G_ASCII_DTOSTR_BUF_SIZE];
dbus_message_iter_get_basic(array_iter, &v_DOUBLE);
g_ascii_dtostr(buf, G_ASCII_DTOSTR_BUF_SIZE, v_DOUBLE);
g_string_append(json_array, buf);
}
break;
default:
/* since we already validated signature, should not happen */
g_assert_not_reached();
break;
}
if (dbus_message_iter_has_next(array_iter)) {
g_string_append(json_array, ",");
}
dbus_message_iter_next(array_iter);
}
g_string_append(json_array, "]");
return g_string_free(json_array, FALSE);
}
static int
add_device(DBusMessage *message, DBusMessage *reply, DBusError *error)
{
DBusMessageIter iter, reply_iter, subiter;
InputOption *tmpo = NULL, *options = NULL;
char *tmp = NULL;
int ret, err;
DeviceIntPtr dev = NULL;
dbus_message_iter_init_append(reply, &reply_iter);
if (!dbus_message_iter_init(message, &iter)) {
ErrorF("[config/dbus] couldn't initialise iterator\n");
MALFORMED_MESSAGE();
}
options = xcalloc(sizeof(*options), 1);
if (!options) {
ErrorF("[config/dbus] couldn't allocate option\n");
return BadAlloc;
}
options->key = xstrdup("_source");
options->value = xstrdup("client/dbus");
if (!options->key || !options->value) {
ErrorF("[config/dbus] couldn't allocate first key/value pair\n");
ret = BadAlloc;
goto unwind;
}
/* signature should be [ss][ss]... */
while (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_ARRAY) {
tmpo = xcalloc(sizeof(*tmpo), 1);
if (!tmpo) {
ErrorF("[config/dbus] couldn't allocate option\n");
ret = BadAlloc;
goto unwind;
}
tmpo->next = options;
options = tmpo;
dbus_message_iter_recurse(&iter, &subiter);
if (dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_STRING)
MALFORMED_MESSAGE();
dbus_message_iter_get_basic(&subiter, &tmp);
if (!tmp)
MALFORMED_MESSAGE();
/* The _ prefix refers to internal settings, and may not be given by
* the client. */
if (tmp[0] == '_') {
ErrorF("[config/dbus] attempted subterfuge: option name %s given\n",
tmp);
MALFORMED_MESSAGE();
}
options->key = xstrdup(tmp);
if (!options->key) {
ErrorF("[config/dbus] couldn't duplicate key!\n");
ret = BadAlloc;
goto unwind;
}
if (!dbus_message_iter_has_next(&subiter))
MALFORMED_MESSAGE();
dbus_message_iter_next(&subiter);
if (dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_STRING)
MALFORMED_MESSAGE();
dbus_message_iter_get_basic(&subiter, &tmp);
if (!tmp)
MALFORMED_MESSAGE();
options->value = xstrdup(tmp);
if (!options->value) {
ErrorF("[config/dbus] couldn't duplicate option!\n");
ret = BadAlloc;
goto unwind;
}
dbus_message_iter_next(&iter);
}
ret = NewInputDeviceRequest(options, &dev);
if (ret != Success) {
DebugF("[config/dbus] NewInputDeviceRequest failed\n");
goto unwind;
}
if (!dev) {
DebugF("[config/dbus] NewInputDeviceRequest provided no device\n");
ret = BadImplementation;
goto unwind;
}
/* XXX: If we fail halfway through, we don't seem to have any way to
* empty the iterator, so you'll end up with some device IDs,
* plus an error. This seems to be a shortcoming in the D-Bus
* API. */
for (; dev; dev = dev->next) {
if (!dbus_message_iter_append_basic(&reply_iter, DBUS_TYPE_INT32,
&dev->id)) {
ErrorF("[config/dbus] couldn't append to iterator\n");
ret = BadAlloc;
goto unwind;
}
}
unwind:
if (ret != Success) {
if (dev)
RemoveDevice(dev);
err = -ret;
dbus_message_iter_append_basic(&reply_iter, DBUS_TYPE_INT32, &err);
}
while (options) {
tmpo = options;
options = options->next;
if (tmpo->key)
xfree(tmpo->key);
if (tmpo->value)
xfree(tmpo->value);
xfree(tmpo);
}
return ret;
}
bool dbus_proc_property(const char *method, DBusMessage *msg,
DBusMessage *reply, DBusError *error,
struct gsh_dbus_interface **interfaces)
{
const char *interface;
const char *prop_name;
bool retval = false;
struct gsh_dbus_interface **iface;
struct gsh_dbus_prop **prop;
DBusMessageIter reply_iter;
dbus_message_iter_init_append(reply, &reply_iter);
if (strcmp(method, "GetAll") == 0) {
DBusMessageIter getall_dict, dict_entry, val_iter;
if (!dbus_message_get_args
(msg, error, DBUS_TYPE_STRING, &interface,
DBUS_TYPE_INVALID))
goto err_out;
iface = lookup_interface(interface, interfaces, error);
if (*iface == NULL)
goto err_out;
if (!dbus_message_iter_open_container
(&reply_iter, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &getall_dict))
goto getall_err;
for (prop = (*iface)->props; prop && *prop; prop++) {
prop_name = (*prop)->name;
if ((*prop)->access == DBUS_PROP_READ
|| (*prop)->access == DBUS_PROP_READWRITE) {
if (!dbus_message_iter_open_container
(&getall_dict, DBUS_TYPE_DICT_ENTRY, NULL,
&dict_entry))
goto getall_err;
if (!dbus_message_iter_append_basic
(&dict_entry, DBUS_TYPE_STRING, &prop_name))
goto getall_err;
if (!dbus_message_iter_open_container
(&dict_entry, DBUS_TYPE_VARIANT,
(*prop)->type, &val_iter))
goto getall_err;
if (!(*prop)->get(&val_iter))
goto getall_err;
if (!dbus_message_iter_close_container
(&dict_entry, &val_iter))
goto getall_err;
if (!dbus_message_iter_close_container
(&getall_dict, &dict_entry))
goto getall_err;
} else {
dbus_set_error(error,
DBUS_ERROR_PROPERTY_READ_ONLY,
"%s of %s from %s (write only?)",
method, prop_name, interface);
/** @todo@ check does write only make sense?? */
goto err_out;
}
}
if (!dbus_message_iter_close_container
(&reply_iter, &getall_dict))
goto getall_err;
return true; /* DONE! */
} else if (strcmp(method, "Get") == 0) {
if (!dbus_message_get_args
(msg, error, DBUS_TYPE_STRING, &interface, DBUS_TYPE_STRING,
&prop_name, DBUS_TYPE_INVALID))
goto err_out;
iface = lookup_interface(interface, interfaces, error);
if (*iface == NULL)
goto err_out;
prop = lookup_property(prop_name, iface, error);
if (*prop == NULL)
goto err_out;
if ((*prop)->access == DBUS_PROP_READ
|| (*prop)->access == DBUS_PROP_READWRITE) {
DBusMessageIter variant_iter;
if (!dbus_message_iter_open_container
(&reply_iter, DBUS_TYPE_VARIANT, (*prop)->type,
&variant_iter)) {
dbus_set_error_const(error, DBUS_ERROR_FAILED,
"Couldn't open Get container");
goto err_out;
}
retval = (*prop)->get(&variant_iter);
if (retval == false ||
!dbus_message_iter_close_container(&reply_iter,
&variant_iter)) {
dbus_set_error_const(error, DBUS_ERROR_FAILED,
"Couldn't close Get container");
goto err_out;
}
} else {
dbus_set_error(error, DBUS_ERROR_PROPERTY_READ_ONLY,
"%s of %s from %s (write only?)", method,
prop_name, interface);
/** @todo@ check does write only make sense?? */
goto err_out;
}
return true; /* DONE! */
} else if (strcmp(method, "Set") == 0) {
DBusMessageIter iter_args;
if (!dbus_message_iter_init(msg, &iter_args)
|| dbus_message_iter_get_arg_type(&iter_args) !=
DBUS_TYPE_STRING) {
goto invalid_args;
}
dbus_message_iter_get_basic(&iter_args, &interface);
if (!dbus_message_iter_next(&iter_args)
|| dbus_message_iter_get_arg_type(&iter_args) !=
DBUS_TYPE_STRING) {
goto invalid_args;
}
dbus_message_iter_get_basic(&iter_args, &prop_name);
if (!dbus_message_iter_next(&iter_args)
|| dbus_message_iter_get_arg_type(&iter_args) !=
DBUS_TYPE_VARIANT
|| dbus_message_iter_has_next(&iter_args)) {
goto invalid_args;
}
iface = lookup_interface(interface, interfaces, error);
if (*iface == NULL)
goto err_out;
prop = lookup_property(prop_name, iface, error);
if (*prop == NULL)
goto err_out;
if ((*prop)->access == DBUS_PROP_WRITE
|| (*prop)->access == DBUS_PROP_READWRITE) {
DBusMessageIter arg;
dbus_message_iter_recurse(&iter_args, &arg);
return (*prop)->set(&arg); /* DONE! */
} else {
dbus_set_error(error, DBUS_ERROR_PROPERTY_READ_ONLY,
"%s of %s from %s", method, prop_name,
interface);
goto err_out;
}
} else {
dbus_set_error(error, DBUS_ERROR_UNKNOWN_METHOD,
"Requested method: %s", method);
}
return retval;
getall_err:
dbus_set_error(error, DBUS_ERROR_FAILED, "GetAll container failure");
goto err_out;
invalid_args:
dbus_set_error(error, DBUS_ERROR_INVALID_ARGS, "Method %s", method);
err_out:
return retval;
}
static QVariant qFetchParameter(DBusMessageIter *it)
{
switch (dbus_message_iter_get_arg_type(it)) {
case DBUS_TYPE_BYTE:
return qVariantFromValue(qIterGet<unsigned char>(it));
case DBUS_TYPE_INT16:
return qVariantFromValue(qIterGet<dbus_int16_t>(it));
case DBUS_TYPE_UINT16:
return qVariantFromValue(qIterGet<dbus_uint16_t>(it));
case DBUS_TYPE_INT32:
return qIterGet<dbus_int32_t>(it);
case DBUS_TYPE_UINT32:
return qIterGet<dbus_uint32_t>(it);
case DBUS_TYPE_DOUBLE:
return qIterGet<double>(it);
case DBUS_TYPE_BOOLEAN:
return bool(qIterGet<dbus_bool_t>(it));
case DBUS_TYPE_INT64:
return static_cast<qlonglong>(qIterGet<dbus_int64_t>(it));
case DBUS_TYPE_UINT64:
return static_cast<qulonglong>(qIterGet<dbus_uint64_t>(it));
case DBUS_TYPE_STRING:
case DBUS_TYPE_OBJECT_PATH:
case DBUS_TYPE_SIGNATURE:
return QString::fromUtf8(qIterGet<char *>(it));
case DBUS_TYPE_VARIANT:
return qIterGet<QVariant>(it);
case DBUS_TYPE_ARRAY: {
int arrayType = dbus_message_iter_get_element_type(it);
switch (arrayType)
{
case DBUS_TYPE_BYTE: {
// QByteArray
DBusMessageIter sub;
dbus_message_iter_recurse(it, &sub);
int len = dbus_message_iter_get_array_len(&sub);
char* data;
dbus_message_iter_get_fixed_array(&sub,&data,&len);
return QByteArray(data,len);
}
case DBUS_TYPE_INT16:
return qFetchList<dbus_int16_t, short>(it);
case DBUS_TYPE_UINT16:
return qFetchList<dbus_uint16_t, ushort>(it);
case DBUS_TYPE_INT32:
return qFetchList<dbus_int32_t, int>(it);
case DBUS_TYPE_UINT32:
return qFetchList<dbus_uint32_t, uint>(it);
case DBUS_TYPE_BOOLEAN:
return qFetchList<dbus_bool_t, bool>(it);
case DBUS_TYPE_DOUBLE:
return qFetchList<double, double>(it);
case DBUS_TYPE_INT64:
return qFetchList<dbus_int64_t, qlonglong>(it);
case DBUS_TYPE_UINT64:
return qFetchList<dbus_uint64_t, qulonglong>(it);
case DBUS_TYPE_STRING:
case DBUS_TYPE_OBJECT_PATH:
case DBUS_TYPE_SIGNATURE:
return qFetchStringList(it);
case DBUS_TYPE_VARIANT:
return qFetchList<QVariant, QVariant>(it);
case DBUS_TYPE_DICT_ENTRY: {
// ### support other types of maps?
QMap<QString, QVariant> map;
DBusMessageIter sub;
dbus_message_iter_recurse(it, &sub);
if (dbus_message_iter_get_array_len(&sub) == 0)
// empty map
return map;
do {
DBusMessageIter itemIter;
dbus_message_iter_recurse(&sub, &itemIter);
Q_ASSERT(dbus_message_iter_has_next(&itemIter));
QString key = qFetchParameter(&itemIter).toString();
dbus_message_iter_next(&itemIter);
map.insertMulti(key, qFetchParameter(&itemIter));
} while (dbus_message_iter_next(&sub));
return map;
}
}
}
// fall through
// common handling for structs and lists of lists (for now)
case DBUS_TYPE_STRUCT: {
QList<QVariant> list;
DBusMessageIter sub;
dbus_message_iter_recurse(it, &sub);
if (dbus_message_iter_get_array_len(&sub) == 0)
return list;
do {
list.append(qFetchParameter(&sub));
} while (dbus_message_iter_next(&sub));
return list;
}
default:
qWarning("Don't know how to handle type %d '%c'", dbus_message_iter_get_arg_type(it), dbus_message_iter_get_arg_type(it));
return QVariant();
break;
}
}
int bridge_request_json_params_parse(bridge_request_t *self, DBusMessageIter *it,
struct json_object **result, const char **key)
{
int ret;
const char *unused;
int type = dbus_message_iter_get_arg_type(it);
*key = 0;
*result = 0;
switch (type) {
case DBUS_TYPE_STRING:
case DBUS_TYPE_SIGNATURE:
case DBUS_TYPE_OBJECT_PATH: {
char *value;
dbus_message_iter_get_basic(it, &value);
*result = json_object_new_string(value);
break;
}
case DBUS_TYPE_UINT16:
case DBUS_TYPE_UINT32:
case DBUS_TYPE_UINT64: {
uint64_t value = 0;
dbus_message_iter_get_basic(it, &value);
*result = json_object_new_int64(value);
break;
}
case DBUS_TYPE_INT16:
case DBUS_TYPE_INT32:
case DBUS_TYPE_INT64:
case DBUS_TYPE_BYTE: {
int64_t value = 0;
dbus_message_iter_get_basic(it, &value);
*result = json_object_new_int64(value);
break;
}
case DBUS_TYPE_DOUBLE: {
double value;
dbus_message_iter_get_basic(it, &value);
*result = json_object_new_double(value);
break;
}
case DBUS_TYPE_BOOLEAN: {
int value;
dbus_message_iter_get_basic(it, &value);
*result = json_object_new_boolean(value);
break;
}
case DBUS_TYPE_ARRAY:
case DBUS_TYPE_STRUCT:
case DBUS_TYPE_VARIANT: {
DBusMessageIter args;
dbus_message_iter_recurse(it, &args);
ret = bridge_request_json_params(self,
&args, result, ((type == DBUS_TYPE_ARRAY) || (type == DBUS_TYPE_STRUCT)));
if (ret != 0)
return ret;
break;
}
case DBUS_TYPE_DICT_ENTRY: {
DBusMessageIter args;
dbus_message_iter_recurse(it, &args);
if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_STRING) {
bridge_request_error(self,
"dictionary with non-string keys not supported.");
return EINVAL;
}
dbus_message_iter_get_basic(&args, key);
if (!dbus_message_iter_has_next(&args))
break;
dbus_message_iter_next(&args);
ret = bridge_request_json_params_parse(self, &args, result, &unused);
if (ret != 0)
return ret;
break;
}
default:
break;
}
if (!*result) {
bridge_request_error(self,
"Unexpected error while parsing D-Bus arguments.");
FCGX_FPrintF(self->request.err, "arg: %i\n", dbus_message_iter_get_arg_type(it));
return EINVAL;
}
return 0;
}
gboolean
ibus_message_iter_has_next (IBusMessageIter *iter)
{
return dbus_message_iter_has_next (iter);
}
static DBusMessage*
handle_query (void *object,
DBusMessage *message,
DBusError *error)
{
DDMDataModel *model;
const char *notification_path;
const char *method_uri;
const char *fetch_string;
DDMDataFetch *fetch;
GHashTable *params = NULL;
DBusMessageIter iter;
DataClientMap *client_map;
HippoDBusModelClient *client;
model = hippo_app_get_data_model(hippo_get_app());
dbus_message_iter_init (message, &iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("First argument should be an object path (notification_path)"));
}
dbus_message_iter_get_basic(&iter, ¬ification_path);
dbus_message_iter_next (&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Second argument should be a string (method_uri)"));
}
dbus_message_iter_get_basic(&iter, &method_uri);
dbus_message_iter_next (&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Third argument should be a string (fetch_string)"));
}
dbus_message_iter_get_basic(&iter, &fetch_string);
dbus_message_iter_next (&iter);
params = read_params_dictionary(&iter);
if (params == NULL)
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Fourth Argument should be a dictionary string=>string (params)"));
if (dbus_message_iter_has_next(&iter))
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Too many arguments"));
fetch = ddm_data_fetch_from_string(fetch_string);
if (fetch == NULL) {
return dbus_message_new_error(message,
DBUS_ERROR_INVALID_ARGS,
_("Couldn't parse fetch string"));
}
client_map = data_client_map_get(model);
client = data_client_map_get_client(client_map, dbus_message_get_sender(message), notification_path);
if (!hippo_dbus_model_client_do_query(client, message, method_uri, fetch, params)) {
/* We've already validated most arguments, so don't worry too much about getting a
* good error message if something goes wrong at this point
*/
return dbus_message_new_error(message,
DBUS_ERROR_FAILED,
_("Couldn't send query"));
}
g_hash_table_destroy(params);
ddm_data_fetch_unref(fetch);
return NULL;
}
