static int ldbus_message_set_error_name(lua_State *L) {
DBusMessage *message = check_DBusMessage(L, 1);
const char * error_name = luaL_optstring(L, 2, NULL);
lua_pushboolean(L, dbus_message_set_error_name(message, error_name));
return 1;
}
static dbus_bool_t
generate_trivial_inner (DBusMessageDataIter *iter,
DBusMessage **message_p)
{
DBusMessage *message;
switch (iter_get_sequence (iter))
{
case 0:
message = dbus_message_new_method_call ("org.freedesktop.TextEditor",
"/foo/bar",
"org.freedesktop.DocumentFactory",
"Create");
break;
case 1:
message = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);
set_reply_serial (message);
break;
case 2:
message = dbus_message_new_signal ("/foo/bar",
"org.freedesktop.DocumentFactory",
"Created");
break;
case 3:
message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
if (!dbus_message_set_error_name (message,
"org.freedesktop.TestErrorName"))
_dbus_assert_not_reached ("oom");
{
DBusMessageIter iter;
const char *v_STRING = "This is an error";
dbus_message_iter_init_append (message, &iter);
if (!dbus_message_iter_append_basic (&iter,
DBUS_TYPE_STRING,
&v_STRING))
_dbus_assert_not_reached ("oom");
}
set_reply_serial (message);
break;
default:
return FALSE;
}
if (message == NULL)
_dbus_assert_not_reached ("oom");
*message_p = message;
return TRUE;
}
static gboolean
dbus_reply_from_exception_and_sender(SeedContext ctx,
const gchar *sender,
dbus_uint32_t serial,
DBusMessage **reply_p,
SeedException *exception)
{
SeedValue name_val;
gchar *s;
const gchar *name = NULL;
*reply_p = NULL;
if (seed_value_is_undefined (ctx, *exception) ||
seed_value_is_null (ctx, *exception) ||
!seed_value_is_object (ctx, *exception))
return FALSE;
name_val = seed_object_get_property(ctx, *exception, "dbusErrorName");
name = seed_value_to_string (ctx, name_val, NULL);
s = seed_exception_to_string (ctx, *exception);
g_warning("JS exception we will send as dbus reply to %s: %s",
sender,
s);
*reply_p = dbus_message_new(DBUS_MESSAGE_TYPE_ERROR);
dbus_message_set_destination(*reply_p, sender);
dbus_message_set_reply_serial(*reply_p, serial);
dbus_message_set_no_reply(*reply_p, TRUE);
dbus_message_set_error_name(*reply_p, name ? name : DBUS_ERROR_FAILED);
if (s != NULL) {
DBusMessageIter iter;
dbus_message_iter_init_append(*reply_p, &iter);
if (!dbus_message_iter_append_basic(&iter,
DBUS_TYPE_STRING,
&s)) {
dbus_message_unref(*reply_p);
g_free(s);
return FALSE;
}
g_free(s);
}
return TRUE;
}
static DBusMessage*
simple_error (void)
{
DBusMessage *message;
message = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
if (message == NULL)
_dbus_assert_not_reached ("oom");
if (!dbus_message_set_error_name (message, "foo.bar"))
_dbus_assert_not_reached ("oom");
set_reply_serial (message);
return message;
}
uint8_t
dbus_svc_send_va
( DBusConnectionState *cs,
dbus_svc_MessageType type,
int32_t reply_serial,
uint32_t *new_serial,
const char *destination,
const char *path,
const char *interface,
const char *member,
dbus_svc_DataType firstType,
va_list va
)
{
DBusMessageIter iter;
char *e;
DBusMessage *msg =
dbus_svc_new_message
( cs,
type,
reply_serial,
destination,
path,
interface,
member
);
if(msg == 0L)
{
if( cs->eh != 0L ) (*(cs->eh))("dbus_svc_send: dbus_svc_new_message failed");
return 0;
}
if( type != DBUS_MESSAGE_TYPE_ERROR )
{
if( !dbus_message_append_args_valist( msg, firstType, va ) )
{
if( cs->eh != 0L ) (*(cs->eh))("dbus_svc_send: dbus_message_append_args_valist failed");
return 0;
}
}else
{
if( firstType == DBUS_TYPE_STRING )
{
e = 0L;
e = va_arg( va, char* );
if( (e == 0L) || !dbus_message_set_error_name( msg, e ) )
{
if( cs->eh != 0L ) (*(cs->eh))("dbus_svc_send: dbus_message_set_error_name failed");
return 0;
}
firstType = va_arg(va, int);
if( firstType == DBUS_TYPE_STRING )
{
e = 0L;
e = va_arg( va, char* );
if( e == 0L )
{
if( cs->eh != 0L ) (*(cs->eh))("dbus_svc_send: NULL error message");
return 0;
}
dbus_message_iter_init_append (msg, &iter);
if( !dbus_message_iter_append_basic
(&iter, DBUS_TYPE_STRING, &e)
)
{
if( cs->eh != 0L ) (*(cs->eh))("dbus_svc_send: dbus_message_iter_append_basic failed");
return 0;
}
}
}else
static dbus_bool_t
generate_special (DBusMessageDataIter *iter,
DBusString *data,
DBusValidity *expected_validity)
{
int item_seq;
DBusMessage *message;
int pos;
dbus_int32_t v_INT32;
_dbus_assert (_dbus_string_get_length (data) == 0);
message = NULL;
pos = -1;
v_INT32 = 42;
item_seq = iter_get_sequence (iter);
if (item_seq == 0)
{
message = simple_method_call ();
if (!dbus_message_append_args (message,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
_dbus_assert_not_reached ("oom");
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
generate_from_message (data, expected_validity, message);
/* set an invalid typecode */
_dbus_string_set_byte (data, pos + 1, '$');
*expected_validity = DBUS_INVALID_UNKNOWN_TYPECODE;
}
else if (item_seq == 1)
{
char long_sig[DBUS_MAXIMUM_TYPE_RECURSION_DEPTH+2];
const char *v_STRING;
int i;
message = simple_method_call ();
if (!dbus_message_append_args (message,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
_dbus_assert_not_reached ("oom");
i = 0;
while (i < (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH + 1))
{
long_sig[i] = DBUS_TYPE_ARRAY;
++i;
}
long_sig[i] = DBUS_TYPE_INVALID;
v_STRING = long_sig;
if (!_dbus_header_set_field_basic (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
DBUS_TYPE_SIGNATURE,
&v_STRING))
_dbus_assert_not_reached ("oom");
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_ARRAY_RECURSION;
}
else if (item_seq == 2)
{
char long_sig[DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*2+4];
const char *v_STRING;
int i;
message = simple_method_call ();
if (!dbus_message_append_args (message,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
_dbus_assert_not_reached ("oom");
i = 0;
while (i <= (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH + 1))
{
long_sig[i] = DBUS_STRUCT_BEGIN_CHAR;
++i;
}
long_sig[i] = DBUS_TYPE_INT32;
++i;
while (i < (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*2 + 3))
{
long_sig[i] = DBUS_STRUCT_END_CHAR;
++i;
}
long_sig[i] = DBUS_TYPE_INVALID;
v_STRING = long_sig;
if (!_dbus_header_set_field_basic (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
DBUS_TYPE_SIGNATURE,
&v_STRING))
_dbus_assert_not_reached ("oom");
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_STRUCT_RECURSION;
}
else if (item_seq == 3)
{
message = simple_method_call ();
if (!dbus_message_append_args (message,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
_dbus_assert_not_reached ("oom");
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
generate_from_message (data, expected_validity, message);
_dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_BEGIN_CHAR);
*expected_validity = DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED;
}
else if (item_seq == 4)
{
message = simple_method_call ();
if (!dbus_message_append_args (message,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
_dbus_assert_not_reached ("oom");
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
generate_from_message (data, expected_validity, message);
_dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_END_CHAR);
*expected_validity = DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED;
}
else if (item_seq == 5)
{
message = simple_method_call ();
if (!dbus_message_append_args (message,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
_dbus_assert_not_reached ("oom");
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
generate_from_message (data, expected_validity, message);
_dbus_string_set_byte (data, pos + 1, DBUS_STRUCT_BEGIN_CHAR);
_dbus_string_set_byte (data, pos + 2, DBUS_STRUCT_END_CHAR);
*expected_validity = DBUS_INVALID_STRUCT_HAS_NO_FIELDS;
}
else if (item_seq == 6)
{
message = simple_method_call ();
generate_from_message (data, expected_validity, message);
_dbus_string_set_byte (data, TYPE_OFFSET, DBUS_MESSAGE_TYPE_INVALID);
*expected_validity = DBUS_INVALID_BAD_MESSAGE_TYPE;
}
else if (item_seq == 7)
{
/* Messages of unknown type are considered valid */
message = simple_method_call ();
generate_from_message (data, expected_validity, message);
_dbus_string_set_byte (data, TYPE_OFFSET, 100);
*expected_validity = DBUS_VALID;
}
else if (item_seq == 8)
{
char byte_order;
message = simple_method_call ();
byte_order = _dbus_header_get_byte_order (&message->header);
generate_from_message (data, expected_validity, message);
_dbus_marshal_set_uint32 (data, BODY_LENGTH_OFFSET,
DBUS_MAXIMUM_MESSAGE_LENGTH / 2 + 4,
byte_order);
_dbus_marshal_set_uint32 (data, FIELDS_ARRAY_LENGTH_OFFSET,
DBUS_MAXIMUM_MESSAGE_LENGTH / 2 + 4,
byte_order);
*expected_validity = DBUS_INVALID_MESSAGE_TOO_LONG;
}
else if (item_seq == 9)
{
const char *v_STRING = "not a valid bus name";
message = simple_method_call ();
if (!_dbus_header_set_field_basic (&message->header,
DBUS_HEADER_FIELD_SENDER,
DBUS_TYPE_STRING, &v_STRING))
_dbus_assert_not_reached ("oom");
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_BAD_SENDER;
}
else if (item_seq == 10)
{
message = simple_method_call ();
if (!dbus_message_set_interface (message, DBUS_INTERFACE_LOCAL))
_dbus_assert_not_reached ("oom");
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_USES_LOCAL_INTERFACE;
}
else if (item_seq == 11)
{
message = simple_method_call ();
if (!dbus_message_set_path (message, DBUS_PATH_LOCAL))
_dbus_assert_not_reached ("oom");
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_USES_LOCAL_PATH;
}
else if (item_seq == 12)
{
/* Method calls don't have to have interface */
message = simple_method_call ();
if (!dbus_message_set_interface (message, NULL))
_dbus_assert_not_reached ("oom");
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_VALID;
}
else if (item_seq == 13)
{
/* Signals require an interface */
message = simple_signal ();
if (!dbus_message_set_interface (message, NULL))
_dbus_assert_not_reached ("oom");
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_MISSING_INTERFACE;
}
else if (item_seq == 14)
{
message = simple_method_return ();
if (!_dbus_header_delete_field (&message->header, DBUS_HEADER_FIELD_REPLY_SERIAL))
_dbus_assert_not_reached ("oom");
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_MISSING_REPLY_SERIAL;
}
else if (item_seq == 15)
{
message = simple_error ();
if (!dbus_message_set_error_name (message, NULL))
_dbus_assert_not_reached ("oom");
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_MISSING_ERROR_NAME;
}
else if (item_seq == 16)
{
char long_sig[DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*4+10];
const char *v_STRING;
int i;
int n_begins;
message = simple_method_call ();
if (!dbus_message_append_args (message,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
_dbus_assert_not_reached ("oom");
i = 0;
while (i <= (DBUS_MAXIMUM_TYPE_RECURSION_DEPTH*3 + 3))
{
long_sig[i] = DBUS_TYPE_ARRAY;
++i;
long_sig[i] = DBUS_DICT_ENTRY_BEGIN_CHAR;
++i;
long_sig[i] = DBUS_TYPE_INT32;
++i;
}
n_begins = i / 3;
long_sig[i] = DBUS_TYPE_INT32;
++i;
while (n_begins > 0)
{
long_sig[i] = DBUS_DICT_ENTRY_END_CHAR;
++i;
n_begins -= 1;
}
long_sig[i] = DBUS_TYPE_INVALID;
v_STRING = long_sig;
if (!_dbus_header_set_field_basic (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
DBUS_TYPE_SIGNATURE,
&v_STRING))
_dbus_assert_not_reached ("oom");
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_EXCEEDED_MAXIMUM_DICT_ENTRY_RECURSION;
}
else if (item_seq == 17)
{
message = simple_method_call ();
if (!dbus_message_append_args (message,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
_dbus_assert_not_reached ("oom");
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
generate_from_message (data, expected_validity, message);
_dbus_string_set_byte (data, pos + 1, DBUS_TYPE_ARRAY);
_dbus_string_set_byte (data, pos + 2, DBUS_DICT_ENTRY_BEGIN_CHAR);
*expected_validity = DBUS_INVALID_DICT_ENTRY_STARTED_BUT_NOT_ENDED;
}
else if (item_seq == 18)
{
message = simple_method_call ();
if (!dbus_message_append_args (message,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
_dbus_assert_not_reached ("oom");
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
generate_from_message (data, expected_validity, message);
_dbus_string_set_byte (data, pos + 1, DBUS_DICT_ENTRY_END_CHAR);
*expected_validity = DBUS_INVALID_DICT_ENTRY_ENDED_BUT_NOT_STARTED;
}
else if (item_seq == 19)
{
message = simple_method_call ();
if (!dbus_message_append_args (message,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INT32, &v_INT32,
DBUS_TYPE_INVALID))
_dbus_assert_not_reached ("oom");
_dbus_header_get_field_raw (&message->header,
DBUS_HEADER_FIELD_SIGNATURE,
NULL, &pos);
generate_from_message (data, expected_validity, message);
_dbus_string_set_byte (data, pos + 1, DBUS_TYPE_ARRAY);
_dbus_string_set_byte (data, pos + 2, DBUS_DICT_ENTRY_BEGIN_CHAR);
_dbus_string_set_byte (data, pos + 3, DBUS_DICT_ENTRY_END_CHAR);
*expected_validity = DBUS_INVALID_DICT_ENTRY_HAS_NO_FIELDS;
}
else if (item_seq == 20)
{
/* 64 levels of nesting is OK */
message = message_with_nesting_levels(64);
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_VALID;
}
else if (item_seq == 21)
{
/* 65 levels of nesting is not OK */
message = message_with_nesting_levels(65);
generate_from_message (data, expected_validity, message);
*expected_validity = DBUS_INVALID_NESTED_TOO_DEEPLY;
}
else
{
return FALSE;
}
if (message)
dbus_message_unref (message);
iter_next (iter);
return TRUE;
}
gboolean
ibus_message_set_error_name (IBusMessage *message,
const gchar *error_name)
{
return dbus_message_set_error_name (message, error_name);
}
