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