//! 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;
}
static enum add_return
add_not_implemented(lua_State *L, int index,
DBusSignatureIter *type, DBusMessageIter *args)
{
(void)index;
(void)args;
lua_pushfstring(L, "(adding type '%s' not implemented yet)",
dbus_signature_iter_get_signature(type));
return ADD_ERROR;
}
static enum add_return
add_array(lua_State *L, int index,
DBusSignatureIter *type, DBusMessageIter *args)
{
DBusSignatureIter array_type;
DBusMessageIter array_args;
char *signature;
add_function af;
int i;
if (!lua_istable(L, index))
return add_error(L, index, LUA_TTABLE);
dbus_signature_iter_recurse(type, &array_type);
signature = dbus_signature_iter_get_signature(&array_type);
dbus_message_iter_open_container(args, DBUS_TYPE_ARRAY,
signature, &array_args);
af = get_addfunc(&array_type);
i = 1;
while (1) {
lua_rawgeti(L, index, i);
if (lua_isnil(L, -1))
break;
if (af(L, -1, &array_type, &array_args) != ADD_OK) {
lua_insert(L, -2);
lua_pop(L, 1);
return ADD_ERROR;
}
lua_pop(L, 1);
i++;
}
lua_pop(L, 1);
dbus_free(signature);
dbus_message_iter_close_container(args, &array_args);
return ADD_OK;
}
static PyObject *
SignatureIter_tp_iternext (SignatureIter *self)
{
char *sig;
PyObject *obj;
/* Stop immediately if finished or not correctly initialized */
if (!self->bytes) return NULL;
sig = dbus_signature_iter_get_signature(&(self->iter));
if (!sig) return PyErr_NoMemory();
obj = PyObject_CallFunction((PyObject *)&DBusPySignature_Type, "s", sig);
dbus_free(sig);
if (!obj) return NULL;
if (!dbus_signature_iter_next(&(self->iter))) {
/* mark object as having been finished with */
Py_CLEAR(self->bytes);
}
return obj;
}
static Eina_Bool
_eldbus_message_iter_arguments_vappend(Eldbus_Message_Iter *iter, const char *signature, va_list *aq)
{
DBusSignatureIter signature_iter;
Eina_Bool r = EINA_TRUE;
char *type;
ELDBUS_MESSAGE_ITERATOR_CHECK_RETVAL(iter, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(iter->writable, EINA_FALSE);
EINA_SAFETY_ON_NULL_RETURN_VAL(signature, EINA_FALSE);
dbus_signature_iter_init(&signature_iter, signature);
while ((type = dbus_signature_iter_get_signature(&signature_iter)))
{
if (type[0] != DBUS_TYPE_VARIANT && !type[1])
r = append_basic(type[0], aq, &iter->dbus_iterator);
else
{
Eldbus_Message_Iter **user_itr;
Eldbus_Message_Iter *sub;
user_itr = va_arg(*aq, Eldbus_Message_Iter **);
sub = _message_iterator_new(EINA_TRUE);
if (!sub)
{
ERR("Could not create sub iterator");
r = EINA_FALSE;
goto next;
}
iter->iterators = eina_inlist_append(iter->iterators,
EINA_INLIST_GET(sub));
if (type[0] == DBUS_TYPE_ARRAY)
r = dbus_message_iter_open_container(&iter->dbus_iterator,
type[0], type+1,
&sub->dbus_iterator);
else if (type[1] == DBUS_TYPE_VARIANT)
{
ERR("variant not supported by \
eldbus_message_iter_arguments_append(), \
try eldbus_message_iter_container_new()");
r = EINA_FALSE;
goto next;
}
else
{
char real_type;
if (type[0] == DBUS_STRUCT_BEGIN_CHAR)
real_type = DBUS_TYPE_STRUCT;
else real_type = DBUS_TYPE_DICT_ENTRY;
r = dbus_message_iter_open_container(&iter->dbus_iterator,
real_type, NULL,
&sub->dbus_iterator);
}
*user_itr = sub;
}
next:
dbus_free(type);
if (!r || !dbus_signature_iter_next(&signature_iter))
break;
}
return r;
}
gboolean js_to_dbus(JSContextRef ctx, const JSValueRef jsvalue,
DBusMessageIter *iter, const char* sig, JSValueRef* exception)
{
DBusSignatureIter s_iter;
dbus_signature_iter_init(&s_iter, sig);
int type;
switch (type = dbus_signature_iter_get_current_type(&s_iter)) {
case DBUS_TYPE_BOOLEAN:
{
dbus_bool_t value = JSValueToBoolean(ctx, jsvalue);
if (!dbus_message_iter_append_basic(iter, type, (void*)&value)) {
g_warning("signatuer:%c error!", type);
return FALSE;
} else {
return TRUE;
}
}
case DBUS_TYPE_DOUBLE:
CASE_NUMBER
{
if (!JSValueIsNumber(ctx, jsvalue)) {
js_fill_exception(ctx, exception, "jsvalue is not an number!");
return FALSE;
}
double value = JSValueToNumber(ctx, jsvalue, NULL);
if (!dbus_message_iter_append_basic(iter, type, (void*)&value)) {
g_warning("signatuer:%c error!", type);
return FALSE;
} else {
return TRUE;
}
}
CASE_STRING
{
char* value = jsvalue_to_cstr(ctx, jsvalue);
if (value == NULL ||
!dbus_message_iter_append_basic(iter, type, (void*)&value)) {
g_free(value);
js_fill_exception(ctx, exception, "jsvalue is not an string or memory not enough!");
return FALSE;
} else {
g_free(value);
return TRUE;
}
}
case DBUS_TYPE_STRUCT:
{
if (!jsvalue_instanceof(ctx, jsvalue, "Array")) {
js_fill_exception(ctx, exception, "jsvalue should an array");
return FALSE;
}
JSPropertyNameArrayRef prop_names =
JSObjectCopyPropertyNames(ctx, (JSObjectRef)jsvalue);
int p_num = JSPropertyNameArrayGetCount(prop_names);
if (p_num == 0) {
JSPropertyNameArrayRelease(prop_names);
js_fill_exception(ctx, exception, "Struct at least have one element!");
return FALSE;
}
DBusMessageIter sub_iter;
OPEN_CONTAINER(iter, type, NULL, &sub_iter);
DBusSignatureIter sub_s_iter;
dbus_signature_iter_recurse(&s_iter, &sub_s_iter);
for (int i=0; i<p_num; i++) {
JSValueRef value = JSObjectGetProperty(ctx,
(JSObjectRef)jsvalue,
JSPropertyNameArrayGetNameAtIndex(prop_names, i),
NULL);
char *sig = dbus_signature_iter_get_signature(&sub_s_iter);
if (!js_to_dbus(ctx, value, &sub_iter, sig, exception)) {
js_fill_exception(ctx, exception, "Failed append struct with sig:%sTODO");
dbus_free(sig);
return FALSE;
}
dbus_free(sig);
if (i != p_num-1 && !dbus_signature_iter_next(&sub_s_iter)) {
JSPropertyNameArrayRelease(prop_names);
CLOSE_CONTAINER(iter, &sub_iter);
js_fill_exception(ctx, exception, "to many params filled to struct");
return FALSE;
}
}
if (dbus_signature_iter_next(&sub_s_iter)) {
JSPropertyNameArrayRelease(prop_names);
CLOSE_CONTAINER(iter, &sub_iter);
js_fill_exception(ctx, exception, "need more params by this struct");
return FALSE;
}
JSPropertyNameArrayRelease(prop_names);
CLOSE_CONTAINER(iter, &sub_iter);
return TRUE;
}
case DBUS_TYPE_ARRAY:
if (dbus_signature_iter_get_element_type(&s_iter) ==
DBUS_TYPE_DICT_ENTRY) {
DBusSignatureIter dict_s_iter;
dbus_signature_iter_recurse(&s_iter, &dict_s_iter);
char *d_sig = dbus_signature_iter_get_signature(&dict_s_iter);
DBusMessageIter sub_iter;
OPEN_CONTAINER(iter, type, d_sig, &sub_iter);
dbus_free(d_sig);
JSPropertyNameArrayRef prop_names = JSObjectCopyPropertyNames(ctx,
(JSObjectRef)jsvalue);
int p_num = JSPropertyNameArrayGetCount(prop_names);
DBusSignatureIter dict_sub_s_iter;
dbus_signature_iter_recurse(&dict_s_iter, &dict_sub_s_iter);
int key_type = dbus_signature_iter_get_current_type(&dict_sub_s_iter);
dbus_signature_iter_next(&dict_sub_s_iter);
char *val_sig = dbus_signature_iter_get_signature(&dict_sub_s_iter);
for (int i=0; i<p_num; i++) {
DBusMessageIter dict_iter;
OPEN_CONTAINER(&sub_iter, DBUS_TYPE_DICT_ENTRY,
NULL, &dict_iter);
JSStringRef key_str = JSPropertyNameArrayGetNameAtIndex(prop_names, i);
//TODO: fetch key type
switch (key_type) {
CASE_STRING
{
char *value = jsstring_to_cstr(ctx, key_str);
dbus_message_iter_append_basic(&dict_iter, key_type, (void*)&value);
g_free(value);
break;
}
case DBUS_TYPE_DOUBLE:
CASE_NUMBER
{
//TODO detect illegal number format
JSValueRef excp;
double value = JSValueToNumber(ctx,
JSValueMakeString(ctx, key_str), &excp);
if (excp != NULL) {
js_fill_exception(ctx, exception, "dict_entry's key must be an number to match the signature!");
return FALSE;
}
dbus_message_iter_append_basic(&dict_iter, key_type,
(void*)&value);
break;
}
default:
{
js_fill_exception(ctx, exception, "DICT_ENTRY's key must basic type, and you should not see this warning in javascript runtime");
dbus_free(val_sig);
JSPropertyNameArrayRelease(prop_names);
CLOSE_CONTAINER(iter, &sub_iter);
return FALSE;
}
}
js_to_dbus(ctx,
JSObjectGetProperty(ctx, (JSObjectRef)jsvalue,
key_str, NULL),
&dict_iter, val_sig,
exception);
CLOSE_CONTAINER(&sub_iter, &dict_iter);
}
dbus_free(val_sig);
JSPropertyNameArrayRelease(prop_names);
CLOSE_CONTAINER(iter, &sub_iter);
return TRUE;
} else {
Eina_Bool
_message_iter_from_eina_value_struct(const char *signature, Eldbus_Message_Iter *iter, const Eina_Value *value)
{
unsigned i;
DBusSignatureIter signature_iter;
Eina_Bool r = EINA_TRUE;
char *type;
Eina_Value_Struct st;
EINA_SAFETY_ON_FALSE_RETURN_VAL(
eina_value_type_get(value) == EINA_VALUE_TYPE_STRUCT, EINA_FALSE);
EINA_SAFETY_ON_FALSE_RETURN_VAL(
eina_value_pget(value, &st), EINA_FALSE);
dbus_signature_iter_init(&signature_iter, signature);
i = 0;
while ((type = dbus_signature_iter_get_signature(&signature_iter)))
{
DBG("type: %s", type);
if (type[0] != 'v' && !type[1])
r = _basic_append(type[0], value, st.desc, i, iter);
else if (type[0] == 'a')
{
Eina_Value value_array;
EINA_SAFETY_ON_FALSE_RETURN_VAL(
_compatible_type(type[0], st.desc->members[i].type),
EINA_FALSE);
eina_value_struct_value_get(value, st.desc->members[i].name,
&value_array);
r = _array_append(type, &value_array, iter);
eina_value_flush(&value_array);
}
else if (type[0] == '(')
{
Eina_Value inner_st;
Eldbus_Message_Iter *sub_iter;
char *sub_sig;
unsigned len = strlen(type+1) -1;
sub_sig = alloca(sizeof(char) * len);
memcpy(sub_sig, type+1, len);
sub_sig[len-1] = 0;
EINA_SAFETY_ON_FALSE_RETURN_VAL(
_compatible_type(type[0], st.desc->members[i].type),
EINA_FALSE);
eina_value_struct_value_get(value, st.desc->members[i].name, &inner_st);
eldbus_message_iter_arguments_append(iter, type, &sub_iter);
r = _message_iter_from_eina_value_struct(sub_sig, sub_iter,
&inner_st);
eldbus_message_iter_container_close(iter, sub_iter);
}
else if (type[0] == 'v')
{
ERR("Variant not supported");
r = EINA_FALSE;
}
else
{
ERR("Unknown type %c", type[0]);
r = EINA_FALSE;
}
i++;
dbus_free(type);
if (!r || !dbus_signature_iter_next(&signature_iter)) break;
}
return r;
}
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;
}
