void tst_QDBusType::benchmarkSignature() { QFETCH(QString, data); QFETCH(bool, useNative); bool result; if (useNative) { dbus_signature_validate(data.toLatin1(), 0); QBENCHMARK { result = dbus_signature_validate(data.toLatin1(), 0); } } else {
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; }
//! Splits signature into atomic DBus object signatures PyObject * script_signature_each(const char *signature) { PyObject *py_list = PyList_New(0); DBusError error; DBusSignatureIter iter; dbus_signature_iter_init(&iter, signature); while (dbus_signature_iter_get_current_type(&iter) != DBUS_TYPE_INVALID) { char *sign = dbus_signature_iter_get_signature(&iter); dbus_error_init(&error); dbus_signature_validate(sign, &error); if (dbus_error_is_set(&error)) { dbus_error_free(&error); return NULL; } else { PyList_Append(py_list, PyString_FromString(sign)); } dbus_free(sign); dbus_signature_iter_next(&iter); } return py_list; }
void tst_QDBusType::isValidSignature() { QFETCH(QString, data); QFETCH(bool, result); data.append(data); if (data.at(0).unicode()) QCOMPARE(bool(dbus_signature_validate(data.toLatin1(), 0)), result); QCOMPARE(QDBusUtil::isValidSignature(data), 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; }
static PyObject * Signature_tp_new (PyTypeObject *cls, PyObject *args, PyObject *kwargs) { const char *str = NULL; PyObject *ignored; static char *argnames[] = {"object_path", "variant_level", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|O:__new__", argnames, &str, &ignored)) return NULL; if (!dbus_signature_validate(str, NULL)) { PyErr_SetString(PyExc_ValueError, "Corrupt type signature"); return NULL; } return (DBusPyStrBase_Type.tp_new)(cls, args, kwargs); }
/** * Check that a type signature is both valid and contains exactly one * complete type. "One complete type" means a single basic type, * array, struct, or dictionary, though the struct or array may be * arbitrarily recursive and complex. More than one complete type * would mean for example "ii" or two integers in sequence. * * @param signature a potentially invalid type signature * @param error error return * @returns #TRUE if signature is valid and has exactly one complete type */ dbus_bool_t dbus_signature_validate_single (const char *signature, DBusError *error) { DBusSignatureIter iter; if (!dbus_signature_validate (signature, error)) return FALSE; dbus_signature_iter_init (&iter, signature); if (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_INVALID) goto lose; if (!dbus_signature_iter_next (&iter)) return TRUE; lose: dbus_set_error (error, DBUS_ERROR_INVALID_SIGNATURE, "Exactly one complete type required in signature"); return FALSE; }
int bridge_request_dbus_params_array(bridge_request_t *self, struct json_object *params, int idx, const char *sig, DBusMessageIter *it) { DBusSignatureIter sigIt; struct json_object *element; int i, ret, len; if (!dbus_signature_validate(sig, 0)) { bridge_request_error(self, "invalid argument signature."); return EINVAL; } dbus_signature_iter_init(&sigIt, sig); len = json_object_array_length(params); for (i = idx; i < len; ++i) { element = json_object_array_get_idx(params, i); if (!element) { bridge_request_error(self, "Unexpected 'null' parameter found."); return EINVAL; } ret = bridge_request_dbus_params_element(self, element, &sigIt, it); if (ret != 0) return ret; if (!dbus_signature_iter_next(&sigIt)) { if (i+1 == len) return 0; bridge_request_error(self, "Unexpected extra parameter found."); return EINVAL; } } bridge_request_error(self, "Aditional parameter expexted."); return EINVAL; }
/** * @ingroup DBusSignatureInternals * Unit test for DBusSignature. * * @returns #TRUE on success. */ dbus_bool_t _dbus_signature_test (void) { DBusSignatureIter iter; DBusSignatureIter subiter; DBusSignatureIter subsubiter; DBusSignatureIter subsubsubiter; const char *sig; dbus_bool_t boolres; _dbus_assert (sizeof (DBusSignatureIter) >= sizeof (DBusSignatureRealIter)); sig = ""; _dbus_assert (dbus_signature_validate (sig, NULL)); _dbus_assert (!dbus_signature_validate_single (sig, NULL)); dbus_signature_iter_init (&iter, sig); _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_INVALID); sig = DBUS_TYPE_STRING_AS_STRING; _dbus_assert (dbus_signature_validate (sig, NULL)); _dbus_assert (dbus_signature_validate_single (sig, NULL)); dbus_signature_iter_init (&iter, sig); _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRING); sig = DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_BYTE_AS_STRING; _dbus_assert (dbus_signature_validate (sig, NULL)); dbus_signature_iter_init (&iter, sig); _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRING); boolres = dbus_signature_iter_next (&iter); _dbus_assert (boolres); _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_BYTE); sig = DBUS_TYPE_UINT16_AS_STRING DBUS_STRUCT_BEGIN_CHAR_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_UINT32_AS_STRING DBUS_TYPE_VARIANT_AS_STRING DBUS_TYPE_DOUBLE_AS_STRING DBUS_STRUCT_END_CHAR_AS_STRING; _dbus_assert (dbus_signature_validate (sig, NULL)); dbus_signature_iter_init (&iter, sig); _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_UINT16); boolres = dbus_signature_iter_next (&iter); _dbus_assert (boolres); _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRUCT); dbus_signature_iter_recurse (&iter, &subiter); _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_STRING); boolres = dbus_signature_iter_next (&subiter); _dbus_assert (boolres); _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_UINT32); boolres = dbus_signature_iter_next (&subiter); _dbus_assert (boolres); _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_VARIANT); boolres = dbus_signature_iter_next (&subiter); _dbus_assert (boolres); _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_DOUBLE); sig = DBUS_TYPE_UINT16_AS_STRING DBUS_STRUCT_BEGIN_CHAR_AS_STRING DBUS_TYPE_UINT32_AS_STRING DBUS_TYPE_BYTE_AS_STRING DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_DOUBLE_AS_STRING DBUS_STRUCT_BEGIN_CHAR_AS_STRING DBUS_TYPE_BYTE_AS_STRING DBUS_STRUCT_END_CHAR_AS_STRING DBUS_STRUCT_END_CHAR_AS_STRING; _dbus_assert (dbus_signature_validate (sig, NULL)); dbus_signature_iter_init (&iter, sig); _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_UINT16); boolres = dbus_signature_iter_next (&iter); _dbus_assert (boolres); _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRUCT); dbus_signature_iter_recurse (&iter, &subiter); _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_UINT32); boolres = dbus_signature_iter_next (&subiter); _dbus_assert (boolres); _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_BYTE); boolres = dbus_signature_iter_next (&subiter); _dbus_assert (boolres); _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_ARRAY); _dbus_assert (dbus_signature_iter_get_element_type (&subiter) == DBUS_TYPE_ARRAY); dbus_signature_iter_recurse (&subiter, &subsubiter); _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_ARRAY); _dbus_assert (dbus_signature_iter_get_element_type (&subsubiter) == DBUS_TYPE_DOUBLE); dbus_signature_iter_recurse (&subsubiter, &subsubsubiter); _dbus_assert (dbus_signature_iter_get_current_type (&subsubsubiter) == DBUS_TYPE_DOUBLE); boolres = dbus_signature_iter_next (&subiter); _dbus_assert (boolres); _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_STRUCT); dbus_signature_iter_recurse (&subiter, &subsubiter); _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_BYTE); sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_INT16_AS_STRING DBUS_TYPE_STRING_AS_STRING DBUS_DICT_ENTRY_END_CHAR_AS_STRING DBUS_TYPE_VARIANT_AS_STRING; _dbus_assert (dbus_signature_validate (sig, NULL)); _dbus_assert (!dbus_signature_validate_single (sig, NULL)); dbus_signature_iter_init (&iter, sig); _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_ARRAY); _dbus_assert (dbus_signature_iter_get_element_type (&iter) == DBUS_TYPE_DICT_ENTRY); dbus_signature_iter_recurse (&iter, &subiter); dbus_signature_iter_recurse (&subiter, &subsubiter); _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_INT16); boolres = dbus_signature_iter_next (&subsubiter); _dbus_assert (boolres); _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_STRING); boolres = dbus_signature_iter_next (&subsubiter); _dbus_assert (!boolres); boolres = dbus_signature_iter_next (&iter); _dbus_assert (boolres); _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_VARIANT); boolres = dbus_signature_iter_next (&iter); _dbus_assert (!boolres); sig = DBUS_TYPE_DICT_ENTRY_AS_STRING; _dbus_assert (!dbus_signature_validate (sig, NULL)); sig = DBUS_TYPE_ARRAY_AS_STRING; _dbus_assert (!dbus_signature_validate (sig, NULL)); sig = DBUS_TYPE_UINT32_AS_STRING DBUS_TYPE_ARRAY_AS_STRING; _dbus_assert (!dbus_signature_validate (sig, NULL)); sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_DICT_ENTRY_AS_STRING; _dbus_assert (!dbus_signature_validate (sig, NULL)); sig = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING; _dbus_assert (!dbus_signature_validate (sig, NULL)); sig = DBUS_DICT_ENTRY_END_CHAR_AS_STRING; _dbus_assert (!dbus_signature_validate (sig, NULL)); sig = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_INT32_AS_STRING; _dbus_assert (!dbus_signature_validate (sig, NULL)); sig = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING DBUS_TYPE_INT32_AS_STRING DBUS_TYPE_STRING_AS_STRING; _dbus_assert (!dbus_signature_validate (sig, NULL)); sig = DBUS_STRUCT_END_CHAR_AS_STRING DBUS_STRUCT_BEGIN_CHAR_AS_STRING; _dbus_assert (!dbus_signature_validate (sig, NULL)); sig = DBUS_STRUCT_BEGIN_CHAR_AS_STRING DBUS_TYPE_BOOLEAN_AS_STRING; _dbus_assert (!dbus_signature_validate (sig, NULL)); return TRUE; #if 0 oom: _dbus_assert_not_reached ("out of memory"); return FALSE; #endif }
//! Validates model file int db_validate_model(iks *xml, char *filename) { /*! * Validates model file. * * @xml Iksemel document * @return 0 on success, -1 on error * */ iks *iface, *met, *arg; DBusError bus_error; dbus_error_init(&bus_error); // Check root tag if (iks_strcmp(iks_name(xml), "comarModel") != 0) { log_error("Not a valid model XML: %s\n", filename); return -1; } for (iface = iks_first_tag(xml); iface; iface = iks_next_tag(iface)) { // Only "interface" tag is allowed if (iks_strcmp(iks_name(iface), "interface") != 0) { log_error("Unknown tag '%s' in XML: %s\n", iks_name(iface), filename); return -1; } // Interfaces must have a "name" attribute if (!iks_strlen(iks_find_attrib(iface, "name"))) { log_error("Model with no name in XML: %s\n", filename); return -1; } for (met = iks_first_tag(iface); met; met = iks_next_tag(met)) { // Only "method" and "signal" tags are allowed if (iks_strcmp(iks_name(met), "method") == 0 || iks_strcmp(iks_name(met), "signal") == 0) { // Tags must have a "name" attribute if (!iks_strlen(iks_find_attrib(met, "name"))) { log_error("Method/Signal tag without name under '%s' in XML: %s\n", iks_find_attrib(iface, "name"), filename); return -1; } for (arg = iks_first_tag(met); arg; arg = iks_next_tag(arg)) { if (iks_strcmp(iks_name(arg), "arg") == 0) { // Arguments must have a "name" attribute if (!iks_strlen(iks_find_attrib(arg, "name"))) { log_error("Argument tag with no name under '%s/%s' in XML: %s\n", iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), filename); return -1; } // Arguments must have a "type" attribute if (!iks_strlen(iks_find_attrib(arg, "type"))) { log_error("Argument tag without type under '%s/%s' in XML: %s\n", iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), filename); return -1; } // Types must be a valid DBus signature if (!dbus_signature_validate(iks_find_attrib(arg, "type"), &bus_error)) { dbus_error_free(&bus_error); log_error("Argument tag with invalid type (%s/%s/%s) in XML: %s\n", iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), iks_find_attrib(arg, "name"), filename); return -1; } // Types must be single type object if (!dbus_signature_validate_single(iks_find_attrib(arg, "type"), &bus_error)) { dbus_error_free(&bus_error); log_error("Argument tag with a non-single element type (%s/%s/%s) in XML: %s\n", iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), iks_find_attrib(arg, "name"), filename); return -1; } } else if (iks_strcmp(iks_name(arg), "annotation") == 0) { // Attributes must have a "name" attribute if (!iks_strlen(iks_find_attrib(arg, "name"))) { log_error("Annotation tag without name under '%s' in XML: %s\n", iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), filename); return -1; } } else { log_error("Unknown tag '%s' under '%s/%s' in XML: %s\n", iks_name(arg), iks_find_attrib(iface, "name"), iks_find_attrib(met, "name"), filename); return -1; } } } else { log_error("Unknown tag '%s' under '%s' in XML: %s\n", iks_name(met), iks_find_attrib(iface, "name"), filename); return -1; } } } return 0; }