static Eina_Bool _eldbus_message_arguments_vappend(Eldbus_Message *msg, const char *signature, va_list *aq) { DBusSignatureIter signature_iter; Eldbus_Message_Iter *iter; int type; Eina_Bool r = EINA_TRUE; if (!signature[0]) return EINA_TRUE; EINA_SAFETY_ON_FALSE_RETURN_VAL(dbus_signature_validate(signature, NULL), EINA_FALSE); iter = eldbus_message_iter_get(msg); EINA_SAFETY_ON_FALSE_RETURN_VAL(iter->writable, EINA_FALSE); dbus_signature_iter_init(&signature_iter, signature); while ((type = dbus_signature_iter_get_current_type(&signature_iter))) { if (dbus_type_is_basic(type)) r = append_basic(type, aq, &iter->dbus_iterator); else { ERR("sig = %s | eldbus_message_arguments_append() and \ eldbus_message_arguments_vappend() only support basic types, \ to complex types use eldbus_message_iter_* functions", signature); r = EINA_FALSE; } if (!r || !dbus_signature_iter_next(&signature_iter)) break; } return r; }
GType _dbus_gtype_from_basic_typecode (int typecode) { g_assert (dbus_type_is_basic (typecode)); g_assert (dbus_typecode_maps_to_basic (typecode)); return typecode_to_gtype (typecode); }
/** Handle connman property changed signals * * @param msg net.connman.Manager.PropertyChanged D-Bus signal */ static void xconnman_handle_property_changed_signal(DBusMessage *msg) { const char *key = 0; dbus_any_t val = DBUS_ANY_INIT; int vtype; DBusMessageIter miter, viter; if( !dbus_message_iter_init(msg, &miter) ) goto EXIT; if( dbus_message_iter_get_arg_type(&miter) != DBUS_TYPE_STRING ) goto EXIT; dbus_message_iter_get_basic(&miter, &key); dbus_message_iter_next(&miter); if( dbus_message_iter_get_arg_type(&miter) != DBUS_TYPE_VARIANT ) goto EXIT; dbus_message_iter_recurse(&miter, &viter); vtype = dbus_message_iter_get_arg_type(&viter); if( !dbus_type_is_basic(vtype) ) goto EXIT; dbus_message_iter_get_basic(&viter, &val); xconnman_property_changed(key, vtype, &val); EXIT: return; }
EAPI Eina_Bool eldbus_message_iter_fixed_array_append(Eldbus_Message_Iter *iter, int type, const void *array, unsigned int size) { ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(array, EINA_FALSE); EINA_SAFETY_ON_FALSE_RETURN_VAL(iter->writable, EINA_FALSE); EINA_SAFETY_ON_FALSE_RETURN_VAL(dbus_type_is_basic(type), EINA_FALSE); return dbus_message_iter_append_fixed_array(&iter->dbus_iterator, type, &array, (int)size); }
/** Handle reply to asynchronous connman properties query * * @param pc State data for asynchronous D-Bus method call * @param user_data (not used) */ static void xconnman_get_properties_cb(DBusPendingCall *pc, void *user_data) { (void)user_data; DBusMessage *rsp = 0; DBusError err = DBUS_ERROR_INIT; const char *key = 0; dbus_any_t val = DBUS_ANY_INIT; int vtype; DBusMessageIter miter, aiter, diter, viter; if( !(rsp = dbus_pending_call_steal_reply(pc)) ) goto EXIT; if( dbus_set_error_from_message(&err, rsp) ) { mce_log(LL_WARN, "%s: %s", err.name, err.message); goto EXIT; } if( !dbus_message_iter_init(rsp, &miter) ) goto EXIT; if( dbus_message_iter_get_arg_type(&miter) != DBUS_TYPE_ARRAY ) goto EXIT; dbus_message_iter_recurse(&miter, &aiter); while( dbus_message_iter_get_arg_type(&aiter) == DBUS_TYPE_DICT_ENTRY ) { dbus_message_iter_recurse(&aiter, &diter); dbus_message_iter_next(&aiter); if( dbus_message_iter_get_arg_type(&diter) != DBUS_TYPE_STRING ) goto EXIT; dbus_message_iter_get_basic(&diter, &key); dbus_message_iter_next(&diter); if( dbus_message_iter_get_arg_type(&diter) != DBUS_TYPE_VARIANT ) goto EXIT; dbus_message_iter_recurse(&diter, &viter); vtype = dbus_message_iter_get_arg_type(&viter); if( !dbus_type_is_basic(vtype) ) continue; dbus_message_iter_get_basic(&viter, &val); xconnman_property_changed(key, vtype, &val); } EXIT: if( rsp ) dbus_message_unref(rsp); dbus_error_free(&err); }
void pa_dbus_append_basic_variant(DBusMessageIter *iter, int type, void *data) { DBusMessageIter variant_iter; pa_assert(iter); pa_assert(dbus_type_is_basic(type)); pa_assert(data); pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, signature_from_basic_type(type), &variant_iter)); pa_assert_se(dbus_message_iter_append_basic(&variant_iter, type, data)); pa_assert_se(dbus_message_iter_close_container(iter, &variant_iter)); }
/** * Useful when iterating over arrays */ EAPI Eina_Bool eldbus_message_iter_get_and_next(Eldbus_Message_Iter *iter, char signature, ...) { char type; va_list vl; ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE); EINA_SAFETY_ON_TRUE_RETURN_VAL(iter->writable, EINA_FALSE); va_start(vl, signature); type = dbus_message_iter_get_arg_type(&iter->dbus_iterator); if (type == DBUS_TYPE_INVALID) { va_end(vl); return EINA_FALSE; } if (type != signature) { if (signature == '(') signature = 'r'; else if (signature == '{') signature = 'e'; if (type != signature) { va_end(vl); return EINA_FALSE; } } if (dbus_type_is_basic(type)) get_basic(type, &iter->dbus_iterator, &vl); else { Eldbus_Message_Iter *sub; Eldbus_Message_Iter **iter_var = va_arg(vl, Eldbus_Message_Iter**); sub = _message_iterator_new(EINA_FALSE); if (!sub) { va_end(vl); return EINA_FALSE; } dbus_message_iter_recurse(&iter->dbus_iterator, &sub->dbus_iterator); iter->iterators = eina_inlist_append(iter->iterators, EINA_INLIST_GET(sub)); *iter_var = sub; } va_end(vl); dbus_message_iter_next(&iter->dbus_iterator); return EINA_TRUE; }
void pa_dbus_append_basic_variant_dict_entry(DBusMessageIter *dict_iter, const char *key, int type, void *data) { DBusMessageIter dict_entry_iter; pa_assert(dict_iter); pa_assert(key); pa_assert(dbus_type_is_basic(type)); pa_assert(data); pa_assert_se(dbus_message_iter_open_container(dict_iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry_iter)); pa_assert_se(dbus_message_iter_append_basic(&dict_entry_iter, DBUS_TYPE_STRING, &key)); pa_dbus_append_basic_variant(&dict_entry_iter, type, data); pa_assert_se(dbus_message_iter_close_container(dict_iter, &dict_entry_iter)); }
void pa_dbus_send_basic_value_reply(DBusConnection *c, DBusMessage *in_reply_to, int type, void *data) { DBusMessage *reply = NULL; pa_assert(c); pa_assert(in_reply_to); pa_assert(dbus_type_is_basic(type)); pa_assert(data); pa_assert_se((reply = dbus_message_new_method_return(in_reply_to))); pa_assert_se(dbus_message_append_args(reply, type, data, DBUS_TYPE_INVALID)); pa_assert_se(dbus_connection_send(c, reply, NULL)); dbus_message_unref(reply); }
void tst_QDBusType::isValidBasicType() { QFETCH(QString, data); QFETCH(bool, result); QFETCH(bool, isValid); QVERIFY2(data.length() == 1, "Test is malformed, this function must test only one-letter types"); QVERIFY(isValid || (!isValid && !result)); int type = data.at(0).unicode(); if (isValid) QCOMPARE(bool(dbus_type_is_basic(type)), result); QCOMPARE(QDBusUtil::isValidBasicType(type), result); }
static Eina_Bool _eldbus_message_iter_arguments_vget(Eldbus_Message_Iter *iter, const char *signature, va_list *aq) { int iter_type; DBusSignatureIter sig_iter; ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE); EINA_SAFETY_ON_TRUE_RETURN_VAL(iter->writable, EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(signature, EINA_FALSE); EINA_SAFETY_ON_FALSE_RETURN_VAL(dbus_signature_validate(signature, NULL), EINA_FALSE); dbus_signature_iter_init(&sig_iter, signature); iter_type = dbus_message_iter_get_arg_type(&iter->dbus_iterator); while (iter_type != DBUS_TYPE_INVALID) { int sig_type = dbus_signature_iter_get_current_type(&sig_iter); if (sig_type == DBUS_TYPE_INVALID) break; if (sig_type != iter_type) { ERR("Type in iterator different of signature expected:%c got %c", iter_type, sig_type); return EINA_FALSE; } if (dbus_type_is_basic(iter_type)) get_basic(iter_type, &iter->dbus_iterator, aq); else { Eldbus_Message_Iter **user_itr = va_arg(*aq, Eldbus_Message_Iter **); Eldbus_Message_Iter *sub_itr; sub_itr = _message_iterator_new(EINA_FALSE); EINA_SAFETY_ON_NULL_RETURN_VAL(sub_itr, EINA_FALSE); dbus_message_iter_recurse(&iter->dbus_iterator, &sub_itr->dbus_iterator); iter->iterators = eina_inlist_append(iter->iterators, EINA_INLIST_GET(sub_itr)); *user_itr = sub_itr; } dbus_message_iter_next(&iter->dbus_iterator); dbus_signature_iter_next(&sig_iter); iter_type = dbus_message_iter_get_arg_type(&iter->dbus_iterator); } return dbus_signature_iter_get_current_type(&sig_iter) == DBUS_TYPE_INVALID; }
void pa_dbus_append_basic_array_variant(DBusMessageIter *iter, int item_type, const void *array, unsigned n) { DBusMessageIter variant_iter; char *array_signature; pa_assert(iter); pa_assert(dbus_type_is_basic(item_type)); pa_assert(array || n == 0); array_signature = pa_sprintf_malloc("a%c", *signature_from_basic_type(item_type)); pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, array_signature, &variant_iter)); pa_dbus_append_basic_array(&variant_iter, item_type, array, n); pa_assert_se(dbus_message_iter_close_container(iter, &variant_iter)); pa_xfree(array_signature); }
void pa_dbus_append_basic_array(DBusMessageIter *iter, int item_type, const void *array, unsigned n) { DBusMessageIter array_iter; unsigned i; unsigned item_size; pa_assert(iter); pa_assert(dbus_type_is_basic(item_type)); pa_assert(array || n == 0); item_size = basic_type_size(item_type); pa_assert_se(dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY, signature_from_basic_type(item_type), &array_iter)); for (i = 0; i < n; ++i) pa_assert_se(dbus_message_iter_append_basic(&array_iter, item_type, &((uint8_t*) array)[i * item_size])); pa_assert_se(dbus_message_iter_close_container(iter, &array_iter)); }
void pa_dbus_append_basic_array_variant_dict_entry( DBusMessageIter *dict_iter, const char *key, int item_type, const void *array, unsigned n) { DBusMessageIter dict_entry_iter; pa_assert(dict_iter); pa_assert(key); pa_assert(dbus_type_is_basic(item_type)); pa_assert(array || n == 0); pa_assert_se(dbus_message_iter_open_container(dict_iter, DBUS_TYPE_DICT_ENTRY, NULL, &dict_entry_iter)); pa_assert_se(dbus_message_iter_append_basic(&dict_entry_iter, DBUS_TYPE_STRING, &key)); pa_dbus_append_basic_array_variant(&dict_entry_iter, item_type, array, n); pa_assert_se(dbus_message_iter_close_container(dict_iter, &dict_entry_iter)); }
void pa_dbus_send_basic_array_variant_reply( DBusConnection *c, DBusMessage *in_reply_to, int item_type, void *array, unsigned n) { DBusMessage *reply = NULL; DBusMessageIter msg_iter; pa_assert(c); pa_assert(in_reply_to); pa_assert(dbus_type_is_basic(item_type)); pa_assert(array || n == 0); pa_assert_se((reply = dbus_message_new_method_return(in_reply_to))); dbus_message_iter_init_append(reply, &msg_iter); pa_dbus_append_basic_array_variant(&msg_iter, item_type, array, n); pa_assert_se(dbus_connection_send(c, reply, NULL)); dbus_message_unref(reply); }
static void iter_append_iter(DBusMessageIter *base, DBusMessageIter *iter) { int type; type = dbus_message_iter_get_arg_type(iter); if (dbus_type_is_basic(type)) { const void *value; dbus_message_iter_get_basic(iter, &value); dbus_message_iter_append_basic(base, type, &value); } else if (dbus_type_is_container(type)) { DBusMessageIter iter_sub, base_sub; char *sig; dbus_message_iter_recurse(iter, &iter_sub); switch (type) { case DBUS_TYPE_ARRAY: case DBUS_TYPE_VARIANT: sig = dbus_message_iter_get_signature(&iter_sub); break; default: sig = NULL; break; } dbus_message_iter_open_container(base, type, sig, &base_sub); if (sig != NULL) dbus_free(sig); while (dbus_message_iter_get_arg_type(&iter_sub) != DBUS_TYPE_INVALID) { iter_append_iter(&base_sub, &iter_sub); dbus_message_iter_next(&iter_sub); } dbus_message_iter_close_container(base, &base_sub); } }
void pa_dbus_send_basic_variant_reply(DBusConnection *c, DBusMessage *in_reply_to, int type, void *data) { DBusMessage *reply = NULL; DBusMessageIter msg_iter; DBusMessageIter variant_iter; pa_assert(c); pa_assert(in_reply_to); pa_assert(dbus_type_is_basic(type)); pa_assert(data); pa_assert_se((reply = dbus_message_new_method_return(in_reply_to))); dbus_message_iter_init_append(reply, &msg_iter); pa_assert_se(dbus_message_iter_open_container(&msg_iter, DBUS_TYPE_VARIANT, signature_from_basic_type(type), &variant_iter)); pa_assert_se(dbus_message_iter_append_basic(&variant_iter, type, data)); pa_assert_se(dbus_message_iter_close_container(&msg_iter, &variant_iter)); pa_assert_se(dbus_connection_send(c, reply, NULL)); dbus_message_unref(reply); }
/** Get property value from dbus message iterator * * @param self property * @param iter dbus message parse position */ static bool uprop_set_from_iter(uprop_t *self, DBusMessageIter *iter) { bool res = false; int type = dbus_message_iter_get_arg_type(iter); uprop_set_invalid(self); if( dbus_type_is_basic(type) ) { dbus_message_iter_get_basic(iter, &self->p_val); switch( dbus_message_iter_get_arg_type(iter) ) { case DBUS_TYPE_STRING: case DBUS_TYPE_OBJECT_PATH: case DBUS_TYPE_SIGNATURE: self->p_val.s = strdup(self->p_val.s); break; default: break; } self->p_type = type, res = true; } return res; }
int main() { if(!dbus_type_is_basic(DBUS_TYPE_BOOLEAN)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_BOOLEAN"); create_xml(1); return 1; } if(!dbus_type_is_basic(DBUS_TYPE_INT16)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_INT16"); create_xml(1); return 1; } if(!dbus_type_is_basic(DBUS_TYPE_BYTE)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_BYTE"); create_xml(1); return 1; } if(!dbus_type_is_basic(DBUS_TYPE_UINT16)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_UINT16"); create_xml(1); return 1; } if(!dbus_type_is_basic(DBUS_TYPE_INT32)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_UINT32"); create_xml(1); return 1; } if(!dbus_type_is_basic(DBUS_TYPE_UINT32)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_UINT32"); create_xml(1); return 1; } if(!dbus_type_is_basic(DBUS_TYPE_INT64)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_INT64"); create_xml(1); return 1; } if(!dbus_type_is_basic(DBUS_TYPE_UINT64)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_UINT64"); create_xml(1); return 1; } if(!dbus_type_is_basic(DBUS_TYPE_DOUBLE)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_DOUBLE"); create_xml(1); return 1; } if(!dbus_type_is_basic(DBUS_TYPE_STRING)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_STRING"); create_xml(1); return 1; } if(!dbus_type_is_basic(DBUS_TYPE_OBJECT_PATH)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_OBJECT_PATH"); create_xml(1); return 1; } if(!dbus_type_is_basic(DBUS_TYPE_SIGNATURE)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_SIGNATURE"); create_xml(1); return 1; } if(dbus_type_is_basic(DBUS_TYPE_ARRAY)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_ARRAY"); create_xml(1); return 1; } if(dbus_type_is_basic(DBUS_TYPE_VARIANT)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_VARIANT"); create_xml(1); return 1; } if(dbus_type_is_basic(DBUS_TYPE_STRUCT)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_STRUCT"); create_xml(1); return 1; } if(dbus_type_is_basic(DBUS_TYPE_DICT_ENTRY)) { std_log(LOG_FILENAME_LINE, "Fail for %s","DBUS_TYPE_DICT_ENTRY"); create_xml(1); return 1; } std_log(LOG_FILENAME_LINE, "Success"); create_xml(0); return 0; }
int bridge_request_dbus_params_element(bridge_request_t *self, struct json_object *element, DBusSignatureIter *sigIt, DBusMessageIter *it) { int type; int ret = 0; type = dbus_signature_iter_get_current_type(sigIt); if (dbus_type_is_basic(type)) { if ((ret = bridge_request_dbus_params_basic(self, element, type, it)) != 0) { return ret; } } else if (type == DBUS_TYPE_VARIANT) { struct json_object *tmp; DBusMessageIter args; const char *vSig; if (json_object_get_type(element) != json_type_array) { bridge_request_error(self, "array expected."); return EINVAL; } tmp = json_object_array_get_idx(element, 0); if (!tmp) { bridge_request_error(self, "variant signature expected."); return EINVAL; } if (json_object_get_type(tmp) != json_type_string) { bridge_request_error(self, "variant signature expected."); return EINVAL; } vSig = json_object_get_string(tmp); if (!dbus_signature_validate_single(vSig, 0)) { bridge_request_error(self, "invalid variant signature."); return EINVAL; } dbus_message_iter_open_container(it, type, vSig, &args); ret = bridge_request_dbus_params_array(self, element, 1, vSig, &args); dbus_message_iter_close_container(it, &args); if (ret != 0) return EINVAL; } else if (type == DBUS_TYPE_STRUCT) { DBusMessageIter args; DBusSignatureIter sigArgs; if (json_object_get_type(element) != json_type_array) { bridge_request_error(self, "array expected."); return EINVAL; } dbus_signature_iter_recurse(sigIt, &sigArgs); dbus_message_iter_open_container(it, type, NULL, &args); ret = bridge_request_dbus_params_struct(self, element, &sigArgs, &args); dbus_message_iter_close_container(it, &args); if (ret != 0) return EINVAL; } else if (type == DBUS_TYPE_ARRAY) { DBusMessageIter args; DBusSignatureIter sigArgs; int cType; char *cSig; dbus_signature_iter_recurse(sigIt, &sigArgs); cType = dbus_signature_iter_get_current_type(&sigArgs); cSig = dbus_signature_iter_get_signature(&sigArgs); dbus_message_iter_open_container(it, type, cSig, &args); dbus_free(cSig); if (cType == DBUS_TYPE_DICT_ENTRY) { ret = bridge_request_dbus_params_dict(self, element, &sigArgs, &args); } else { int i, len; if (json_object_get_type(element) != json_type_array) { bridge_request_error(self, "array expected."); ret = EINVAL; } else { len = json_object_array_length(element); for (i = 0; i < len; ++i) { struct json_object *tmp; DBusSignatureIter tmpSigArgs = sigArgs; tmp = json_object_array_get_idx(element, i); if (!tmp) { bridge_request_error(self, "unexpected 'null' element in json array."); return EINVAL; } ret = bridge_request_dbus_params_element(self, tmp, &tmpSigArgs, &args); } } } dbus_message_iter_close_container(it, &args); } else { bridge_request_error(self, "unsupported json argument type."); return EINVAL; } return ret; }
/** * Verifies that the range of type_str from type_pos to type_end is a * valid signature. If this function returns #TRUE, it will be safe * to iterate over the signature with a types-only #DBusTypeReader. * The range passed in should NOT include the terminating * nul/DBUS_TYPE_INVALID. * * @param type_str the string * @param type_pos where the typecodes start * @param len length of typecodes * @returns #DBUS_VALID if valid, reason why invalid otherwise */ DBusValidity _dbus_validate_signature_with_reason (const DBusString *type_str, int type_pos, int len) { const unsigned char *p; const unsigned char *end; int last; int struct_depth; int array_depth; int dict_entry_depth; DBusValidity result; int element_count; DBusList *element_count_stack; result = DBUS_VALID; element_count_stack = NULL; if (!_dbus_list_append (&element_count_stack, _DBUS_INT_TO_POINTER (0))) { result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR; goto out; } _dbus_assert (type_str != NULL); _dbus_assert (type_pos < _DBUS_INT32_MAX - len); _dbus_assert (len >= 0); _dbus_assert (type_pos >= 0); if (len > DBUS_MAXIMUM_SIGNATURE_LENGTH) { result = DBUS_INVALID_SIGNATURE_TOO_LONG; goto out; } p = _dbus_string_get_const_data_len (type_str, type_pos, 0); end = _dbus_string_get_const_data_len (type_str, type_pos + len, 0); struct_depth = 0; array_depth = 0; dict_entry_depth = 0; last = DBUS_TYPE_INVALID; while (p != end) { switch (*p) { case DBUS_TYPE_BYTE: case DBUS_TYPE_BOOLEAN: case DBUS_TYPE_INT16: case DBUS_TYPE_UINT16: case DBUS_TYPE_INT32: case DBUS_TYPE_UINT32: case DBUS_TYPE_INT64: case DBUS_TYPE_UINT64: case DBUS_TYPE_DOUBLE: case DBUS_TYPE_STRING: case DBUS_TYPE_OBJECT_PATH: case DBUS_TYPE_SIGNATURE: case DBUS_TYPE_VARIANT: break; case DBUS_TYPE_ARRAY: array_depth += 1; if (array_depth > DBUS_MAXIMUM_TYPE_RECURSION_DEPTH) { result = DBUS_INVALID_EXCEEDED_MAXIMUM_ARRAY_RECURSION; goto out; } break; case DBUS_STRUCT_BEGIN_CHAR: struct_depth += 1; if (struct_depth > DBUS_MAXIMUM_TYPE_RECURSION_DEPTH) { result = DBUS_INVALID_EXCEEDED_MAXIMUM_STRUCT_RECURSION; goto out; } if (!_dbus_list_append (&element_count_stack, _DBUS_INT_TO_POINTER (0))) { result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR; goto out; } break; case DBUS_STRUCT_END_CHAR: if (struct_depth == 0) { result = DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED; goto out; } if (last == DBUS_STRUCT_BEGIN_CHAR) { result = DBUS_INVALID_STRUCT_HAS_NO_FIELDS; goto out; } _dbus_list_pop_last (&element_count_stack); struct_depth -= 1; break; case DBUS_DICT_ENTRY_BEGIN_CHAR: if (last != DBUS_TYPE_ARRAY) { result = DBUS_INVALID_DICT_ENTRY_NOT_INSIDE_ARRAY; goto out; } dict_entry_depth += 1; if (dict_entry_depth > DBUS_MAXIMUM_TYPE_RECURSION_DEPTH) { result = DBUS_INVALID_EXCEEDED_MAXIMUM_DICT_ENTRY_RECURSION; goto out; } if (!_dbus_list_append (&element_count_stack, _DBUS_INT_TO_POINTER (0))) { result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR; goto out; } break; case DBUS_DICT_ENTRY_END_CHAR: if (dict_entry_depth == 0) { result = DBUS_INVALID_DICT_ENTRY_ENDED_BUT_NOT_STARTED; goto out; } dict_entry_depth -= 1; element_count = _DBUS_POINTER_TO_INT (_dbus_list_pop_last (&element_count_stack)); if (element_count != 2) { if (element_count == 0) result = DBUS_INVALID_DICT_ENTRY_HAS_NO_FIELDS; else if (element_count == 1) result = DBUS_INVALID_DICT_ENTRY_HAS_ONLY_ONE_FIELD; else result = DBUS_INVALID_DICT_ENTRY_HAS_TOO_MANY_FIELDS; goto out; } break; case DBUS_TYPE_STRUCT: /* doesn't appear in signatures */ case DBUS_TYPE_DICT_ENTRY: /* ditto */ default: result = DBUS_INVALID_UNKNOWN_TYPECODE; goto out; } if (*p != DBUS_TYPE_ARRAY && *p != DBUS_DICT_ENTRY_BEGIN_CHAR && *p != DBUS_STRUCT_BEGIN_CHAR) { element_count = _DBUS_POINTER_TO_INT (_dbus_list_pop_last (&element_count_stack)); ++element_count; if (!_dbus_list_append (&element_count_stack, _DBUS_INT_TO_POINTER (element_count))) { result = DBUS_VALIDITY_UNKNOWN_OOM_ERROR; goto out; } } if (array_depth > 0) { if (*p == DBUS_TYPE_ARRAY && p != end) { const char *p1; p1 = p + 1; if (*p1 == DBUS_STRUCT_END_CHAR || *p1 == DBUS_DICT_ENTRY_END_CHAR) { result = DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE; goto out; } } else { array_depth = 0; } } if (last == DBUS_DICT_ENTRY_BEGIN_CHAR && !dbus_type_is_basic (*p)) { result = DBUS_INVALID_DICT_KEY_MUST_BE_BASIC_TYPE; goto out; } last = *p; ++p; } if (array_depth > 0) { result = DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE; goto out; } if (struct_depth > 0) { result = DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED; goto out; } if (dict_entry_depth > 0) { result = DBUS_INVALID_DICT_ENTRY_STARTED_BUT_NOT_ENDED; goto out; } _dbus_assert (last != DBUS_TYPE_ARRAY); _dbus_assert (last != DBUS_STRUCT_BEGIN_CHAR); _dbus_assert (last != DBUS_DICT_ENTRY_BEGIN_CHAR); result = DBUS_VALID; out: _dbus_list_clear (&element_count_stack); return result; }
gboolean g_dbus_proxy_set_property_array(GDBusProxy *proxy, const char *name, int type, const void *value, size_t size, GDBusResultFunction function, void *user_data, GDBusDestroyFunction destroy) { struct set_property_data *data; GDBusClient *client; DBusMessage *msg; DBusMessageIter iter, variant, array; DBusPendingCall *call; char array_sig[3]; char type_sig[2]; if (!proxy || !name || !value) return FALSE; if (!dbus_type_is_basic(type)) return FALSE; client = proxy->client; if (!client) return FALSE; data = g_try_new0(struct set_property_data, 1); if (!data) return FALSE; data->function = function; data->user_data = user_data; data->destroy = destroy; msg = dbus_message_new_method_call(client->service_name, proxy->obj_path, DBUS_INTERFACE_PROPERTIES, "Set"); if (!msg) { g_free(data); return FALSE; } array_sig[0] = DBUS_TYPE_ARRAY; array_sig[1] = (char) type; array_sig[2] = '\0'; type_sig[0] = (char) type; type_sig[1] = '\0'; dbus_message_iter_init_append(msg, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &proxy->interface); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, array_sig, &variant); dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY, type_sig, &array); if (dbus_type_is_fixed(type)) dbus_message_iter_append_fixed_array(&array, type, &value, size); else if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH) { const char **str = (const char **) value; size_t i; for (i = 0; i < size; i++) dbus_message_iter_append_basic(&array, type, &str[i]); } dbus_message_iter_close_container(&variant, &array); dbus_message_iter_close_container(&iter, &variant); if (g_dbus_send_message_with_reply(client->dbus_conn, msg, &call, -1) == FALSE) { dbus_message_unref(msg); g_free(data); return FALSE; } dbus_pending_call_set_notify(call, set_property_reply, data, g_free); dbus_pending_call_unref(call); dbus_message_unref(msg); return TRUE; }
gboolean g_dbus_proxy_set_property_basic(GDBusProxy *proxy, const char *name, int type, const void *value, GDBusResultFunction function, void *user_data, GDBusDestroyFunction destroy) { struct set_property_data *data; GDBusClient *client; DBusMessage *msg; DBusMessageIter iter, variant; DBusPendingCall *call; char type_as_str[2]; if (proxy == NULL || name == NULL || value == NULL) return FALSE; if (dbus_type_is_basic(type) == FALSE) return FALSE; client = proxy->client; if (client == NULL) return FALSE; data = g_try_new0(struct set_property_data, 1); if (data == NULL) return FALSE; data->function = function; data->user_data = user_data; data->destroy = destroy; msg = dbus_message_new_method_call(client->service_name, proxy->obj_path, DBUS_INTERFACE_PROPERTIES, "Set"); if (msg == NULL) { g_free(data); return FALSE; } type_as_str[0] = (char) type; type_as_str[1] = '\0'; dbus_message_iter_init_append(msg, &iter); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &proxy->interface); dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name); dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, type_as_str, &variant); dbus_message_iter_append_basic(&variant, type, value); dbus_message_iter_close_container(&iter, &variant); if (g_dbus_send_message_with_reply(client->dbus_conn, msg, &call, -1) == FALSE) { dbus_message_unref(msg); g_free(data); return FALSE; } dbus_pending_call_set_notify(call, set_property_reply, data, g_free); dbus_pending_call_unref(call); dbus_message_unref(msg); return TRUE; }