+2003-02-24 Anders Carlsson <set EMAIL_ADDRESS environment variable>
+
+ * dbus/dbus-internals.c: (_dbus_type_to_string):
+ * dbus/dbus-marshal.c: (_dbus_marshal_get_arg_end_pos),
+ (_dbus_marshal_validate_arg):
+ * dbus/dbus-message-builder.c: (_dbus_message_data_load):
+ * dbus/dbus-message.c: (dbus_message_append_args_valist),
+ (dbus_message_append_boolean), (dbus_message_append_boolean_array),
+ (dbus_message_get_args_valist), (dbus_message_iter_get_boolean),
+ (dbus_message_iter_get_int32), (dbus_message_iter_get_uint32),
+ (dbus_message_iter_get_double),
+ (dbus_message_iter_get_boolean_array), (message_iter_test):
+ * dbus/dbus-message.h:
+ * dbus/dbus-protocol.h:
+ * doc/dbus-specification.sgml:
+ * test/data/valid-messages/lots-of-arguments.message:
+
2003-02-23 Havoc Pennington <hp@pobox.com>
* dbus/dbus-keyring.c: finish most of this implementation and
return "invalid";
case DBUS_TYPE_NIL:
return "nil";
+ case DBUS_TYPE_BOOLEAN:
+ return "boolean";
case DBUS_TYPE_INT32:
return "int32";
case DBUS_TYPE_UINT32:
return "double";
case DBUS_TYPE_STRING:
return "string";
+ case DBUS_TYPE_BOOLEAN_ARRAY:
+ return "boolean array";
case DBUS_TYPE_INT32_ARRAY:
return "int32 array";
case DBUS_TYPE_UINT32_ARRAY:
case DBUS_TYPE_NIL:
*end_pos = pos + 1;
break;
+
+ case DBUS_TYPE_BOOLEAN:
+ *end_pos = pos + 2;
+ break;
case DBUS_TYPE_INT32:
*end_pos = _DBUS_ALIGN_VALUE (pos + 1, sizeof (dbus_int32_t)) + sizeof (dbus_int32_t);
}
break;
+ case DBUS_TYPE_BOOLEAN_ARRAY:
case DBUS_TYPE_BYTE_ARRAY:
{
int len;
case DBUS_TYPE_NIL:
*end_pos = pos + 1;
break;
+
+ case DBUS_TYPE_BOOLEAN:
+ *end_pos = pos + 2;
+ break;
case DBUS_TYPE_INT32:
case DBUS_TYPE_UINT32:
}
break;
+ case DBUS_TYPE_BOOLEAN_ARRAY:
case DBUS_TYPE_BYTE_ARRAY:
{
int len;
code = DBUS_TYPE_INVALID;
else if (_dbus_string_starts_with_c_str (&line, "NIL"))
code = DBUS_TYPE_NIL;
+ else if (_dbus_string_starts_with_c_str (&line, "BOOLEAN_ARRAY"))
+ code = DBUS_TYPE_BOOLEAN_ARRAY;
else if (_dbus_string_starts_with_c_str (&line, "INT32_ARRAY"))
code = DBUS_TYPE_INT32_ARRAY;
else if (_dbus_string_starts_with_c_str (&line, "UINT32_ARRAY"))
code = DBUS_TYPE_BYTE_ARRAY;
else if (_dbus_string_starts_with_c_str (&line, "STRING_ARRAY"))
code = DBUS_TYPE_STRING_ARRAY;
+ else if (_dbus_string_starts_with_c_str (&line, "BOOLEAN"))
+ code = DBUS_TYPE_BOOLEAN;
else if (_dbus_string_starts_with_c_str (&line, "INT32"))
code = DBUS_TYPE_INT32;
else if (_dbus_string_starts_with_c_str (&line, "UINT32"))
}
}
else if (_dbus_string_starts_with_c_str (&line,
+ "BOOLEAN_ARRAY"))
+ {
+ SAVE_FOR_UNALIGN (dest, 4);
+ int i, len, allocated;
+ unsigned char *values;
+ unsigned char b, val;
+
+ allocated = 4;
+ values = dbus_new (unsigned char, allocated);
+ if (!values)
+ {
+ _dbus_warn ("could not allocate memory for BOOLEAN_ARRAY\n");
+ goto parse_failed;
+ }
+
+ len = 0;
+
+ _dbus_string_delete_first_word (&line);
+ _dbus_string_skip_blank (&line, 0, &i);
+ b = _dbus_string_get_byte (&line, i++);
+
+ if (b != '{')
+ goto parse_failed;
+
+ while (i < _dbus_string_get_length (&line))
+ {
+ _dbus_string_skip_blank (&line, i, &i);
+ printf ("i is: %d\n", i);
+
+ if (_dbus_string_find_to (&line, i, i + 5,
+ "false", NULL))
+ {
+ i += 5;
+ val = TRUE;
+ }
+ else if (_dbus_string_find_to (&line, i, i + 4,
+ "true", NULL))
+ {
+ i += 4;
+ val = FALSE;
+ }
+ else
+ {
+ _dbus_warn ("could not parse BOOLEAN_ARRAY\n");
+ goto parse_failed;
+ }
+
+ values[len++] = val;
+ if (len == allocated)
+ {
+ allocated *= 2;
+ values = dbus_realloc (values, allocated * sizeof (unsigned char));
+ if (!values)
+ {
+ _dbus_warn ("could not allocate memory for BOOLEAN_ARRAY\n");
+ goto parse_failed;
+ }
+ }
+
+ _dbus_string_skip_blank (&line, i, &i);
+
+ b = _dbus_string_get_byte (&line, i++);
+
+ if (b == '}')
+ break;
+ else if (b != ',')
+ goto parse_failed;
+ }
+
+ if (!_dbus_marshal_int32 (dest, endian, len) ||
+ !_dbus_string_append_len (dest, values, len))
+ {
+ _dbus_warn ("failed to append BOOLEAN_ARRAY\n");
+ goto parse_failed;
+ }
+ dbus_free (values);
+
+ PERFORM_UNALIGN (dest);
+ }
+ else if (_dbus_string_starts_with_c_str (&line,
"INT32_ARRAY"))
{
SAVE_FOR_UNALIGN (dest, 4);
PERFORM_UNALIGN (dest);
}
else if (_dbus_string_starts_with_c_str (&line,
+ "BOOLEAN"))
+ {
+ unsigned char val;
+
+ _dbus_string_delete_first_word (&line);
+
+ if (_dbus_string_starts_with_c_str (&line, "true"))
+ val = TRUE;
+ else if (_dbus_string_starts_with_c_str (&line, "false"))
+ val = FALSE;
+ else
+ {
+ _dbus_warn ("could not parse BOOLEAN\n");
+ goto parse_failed;
+ }
+ if (!_dbus_string_append_byte (dest, val))
+ {
+ _dbus_warn ("failed to append BOOLEAN\n");
+ goto parse_failed;
+ }
+ }
+
+ else if (_dbus_string_starts_with_c_str (&line,
"INT32"))
{
SAVE_FOR_UNALIGN (dest, 4);
case DBUS_TYPE_NIL:
if (!dbus_message_append_nil (message))
goto enomem;
+ case DBUS_TYPE_BOOLEAN:
+ if (!dbus_message_append_boolean (message, va_arg (var_args, dbus_bool_t)))
+ goto enomem;
case DBUS_TYPE_INT32:
if (!dbus_message_append_int32 (message, va_arg (var_args, dbus_int32_t)))
goto enomem;
if (!dbus_message_append_string (message, va_arg (var_args, const char *)))
goto enomem;
break;
+ case DBUS_TYPE_BOOLEAN_ARRAY:
+ {
+ int len;
+ unsigned char *data;
+
+ data = va_arg (var_args, unsigned char *);
+ len = va_arg (var_args, int);
+
+ if (!dbus_message_append_boolean_array (message, data, len))
+ goto enomem;
+ }
+ break;
case DBUS_TYPE_INT32_ARRAY:
{
int len;
}
/**
+ * Appends a boolean value to the message
+ *
+ * @param message the message
+ * @param value the boolean value
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+dbus_message_append_boolean (DBusMessage *message,
+ unsigned char value)
+{
+ _dbus_assert (!message->locked);
+
+ if (!_dbus_string_append_byte (&message->body, DBUS_TYPE_BOOLEAN))
+ return FALSE;
+
+ if (!_dbus_string_append_byte (&message->body, (value != FALSE)))
+ {
+ _dbus_string_shorten (&message->body, 1);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/**
* Appends a 32 bit signed integer to the message.
*
* @param message the message
}
/**
+ * Appends a boolean array to the message.
+ *
+ * @param message the message
+ * @param value the array
+ * @param len the length of the array
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+dbus_message_append_boolean_array (DBusMessage *message,
+ unsigned char *value,
+ int len)
+{
+ _dbus_assert (!message->locked);
+
+ if (!_dbus_string_append_byte (&message->body, DBUS_TYPE_BOOLEAN_ARRAY))
+ return FALSE;
+
+ if (!_dbus_marshal_byte_array (&message->body, message->byte_order, value, len))
+ {
+ _dbus_string_shorten (&message->body, 1);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/**
* Appends a 32 bit signed integer array to the message.
*
* @param message the message
switch (spec_type)
{
+ case DBUS_TYPE_NIL:
+ break;
+ case DBUS_TYPE_BOOLEAN:
+ {
+ unsigned char *ptr;
+
+ ptr = va_arg (var_args, unsigned char *);
+
+ *ptr = dbus_message_iter_get_boolean (iter);
+ break;
+ }
case DBUS_TYPE_INT32:
{
dbus_int32_t *ptr;
break;
}
+ case DBUS_TYPE_BOOLEAN_ARRAY:
+ {
+ unsigned char **ptr;
+ int *len;
+
+ ptr = va_arg (var_args, unsigned char **);
+ len = va_arg (var_args, int *);
+
+ if (!dbus_message_iter_get_boolean_array (iter, ptr, len))
+ return DBUS_RESULT_NO_MEMORY;
+
+ break;
+ }
+
case DBUS_TYPE_INT32_ARRAY:
{
dbus_int32_t **ptr;
* Note that you need to check that the iterator points to
* a string value before using this function.
*
- * @see dbus_message_iter_get_field_type
+ * @see dbus_message_iter_get_arg_type
* @param iter the message iter
* @returns the string
*/
}
/**
+ * Returns the boolean value that an iterator may point to.
+ * Note that you need to check that the iterator points to
+ * a boolean value before using this function.
+ *
+ * @see dbus_message_iter_get_arg_type
+ * @param iter the message iter
+ * @returns the string
+ */
+unsigned char
+dbus_message_iter_get_boolean (DBusMessageIter *iter)
+{
+ unsigned char value;
+
+ _dbus_assert (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_BOOLEAN);
+
+ value = _dbus_string_get_byte (&iter->message->body, iter->pos + 1);
+ iter->pos += 2;
+
+ return value;
+}
+
+/**
* Returns the 32 bit signed integer value that an iterator may point to.
* Note that you need to check that the iterator points to
* an integer value before using this function.
*
- * @see dbus_message_iter_get_field_type
+ * @see dbus_message_iter_get_arg_type
* @param iter the message iter
* @returns the integer
*/
int
dbus_message_iter_get_int32 (DBusMessageIter *iter)
{
+ _dbus_assert (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_INT32);
+
return _dbus_demarshal_int32 (&iter->message->body, iter->message->byte_order,
iter->pos + 1, NULL);
}
* Note that you need to check that the iterator points to
* an unsigned integer value before using this function.
*
- * @see dbus_message_iter_get_field_type
+ * @see dbus_message_iter_get_arg_type
* @param iter the message iter
* @returns the integer
*/
int
dbus_message_iter_get_uint32 (DBusMessageIter *iter)
{
+ _dbus_assert (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_UINT32);
+
return _dbus_demarshal_uint32 (&iter->message->body, iter->message->byte_order,
iter->pos + 1, NULL);
}
* Note that you need to check that the iterator points to
* a string value before using this function.
*
- * @see dbus_message_iter_get_field_type
+ * @see dbus_message_iter_get_arg_type
* @param iter the message iter
* @returns the double
*/
double
dbus_message_iter_get_double (DBusMessageIter *iter)
{
+ _dbus_assert (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_DOUBLE);
+
return _dbus_demarshal_double (&iter->message->body, iter->message->byte_order,
iter->pos + 1, NULL);
}
/**
+ * Returns the boolean array that the iterator may point to. Note that
+ * you need to check that the iterator points to an array of the
+ * correct type prior to using this function.
+ *
+ * @param iter the iterator
+ * @param value return location for the array
+ * @param len return location for the array length
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+dbus_message_iter_get_boolean_array (DBusMessageIter *iter,
+ unsigned char **value,
+ int *len)
+{
+ _dbus_assert (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_BOOLEAN_ARRAY);
+
+ *value = _dbus_demarshal_byte_array (&iter->message->body, iter->message->byte_order,
+ iter->pos + 1, NULL, len);
+
+ if (!*value)
+ return FALSE;
+ else
+ return TRUE;
+}
+
+/**
* Returns the 32 bit signed integer array that the iterator may point
* to. Note that you need to check that the iterator points to an
* array of the correct type prior to using this function.
if (dbus_message_iter_get_arg_type (iter) != DBUS_TYPE_UINT32)
_dbus_assert_not_reached ("Argument type isn't int32");
- if (dbus_message_iter_get_int32 (iter) != 0xedd1e)
+ if (dbus_message_iter_get_uint32 (iter) != 0xedd1e)
_dbus_assert_not_reached ("Unsigned integers differ");
if (!dbus_message_iter_next (iter))
dbus_bool_t dbus_message_name_is (DBusMessage *message,
const char *name);
-dbus_bool_t dbus_message_append_args (DBusMessage *message,
- int first_arg_type,
- ...);
-dbus_bool_t dbus_message_append_args_valist (DBusMessage *message,
- int first_arg_type,
- va_list var_args);
-dbus_bool_t dbus_message_append_nil (DBusMessage *message);
-dbus_bool_t dbus_message_append_int32 (DBusMessage *message,
- dbus_int32_t value);
-dbus_bool_t dbus_message_append_uint32 (DBusMessage *message,
- dbus_uint32_t value);
-dbus_bool_t dbus_message_append_double (DBusMessage *message,
- double value);
-dbus_bool_t dbus_message_append_string (DBusMessage *message,
- const char *value);
-dbus_bool_t dbus_message_append_int32_array (DBusMessage *message,
- const dbus_int32_t *value,
- int len);
-dbus_bool_t dbus_message_append_uint32_array (DBusMessage *message,
- const dbus_uint32_t *value,
- int len);
-dbus_bool_t dbus_message_append_double_array (DBusMessage *message,
- const double *value,
- int len);
-dbus_bool_t dbus_message_append_byte_array (DBusMessage *message,
- unsigned const char *value,
- int len);
-dbus_bool_t dbus_message_append_string_array (DBusMessage *message,
- const char **value,
- int len);
+dbus_bool_t dbus_message_append_args (DBusMessage *message,
+ int first_arg_type,
+ ...);
+dbus_bool_t dbus_message_append_args_valist (DBusMessage *message,
+ int first_arg_type,
+ va_list var_args);
+dbus_bool_t dbus_message_append_nil (DBusMessage *message);
+dbus_bool_t dbus_message_append_boolean (DBusMessage *message,
+ unsigned char value);
+dbus_bool_t dbus_message_append_int32 (DBusMessage *message,
+ dbus_int32_t value);
+dbus_bool_t dbus_message_append_uint32 (DBusMessage *message,
+ dbus_uint32_t value);
+dbus_bool_t dbus_message_append_double (DBusMessage *message,
+ double value);
+dbus_bool_t dbus_message_append_string (DBusMessage *message,
+ const char *value);
+dbus_bool_t dbus_message_append_boolean_array (DBusMessage *message,
+ unsigned char *value,
+ int len);
+dbus_bool_t dbus_message_append_int32_array (DBusMessage *message,
+ const dbus_int32_t *value,
+ int len);
+dbus_bool_t dbus_message_append_uint32_array (DBusMessage *message,
+ const dbus_uint32_t *value,
+ int len);
+dbus_bool_t dbus_message_append_double_array (DBusMessage *message,
+ const double *value,
+ int len);
+dbus_bool_t dbus_message_append_byte_array (DBusMessage *message,
+ unsigned const char *value,
+ int len);
+dbus_bool_t dbus_message_append_string_array (DBusMessage *message,
+ const char **value,
+ int len);
+
DBusMessageIter *dbus_message_get_args_iter (DBusMessage *message);
DBusResultCode dbus_message_get_args (DBusMessage *message,
-void dbus_message_iter_ref (DBusMessageIter *iter);
-void dbus_message_iter_unref (DBusMessageIter *iter);
-dbus_bool_t dbus_message_iter_has_next (DBusMessageIter *iter);
-dbus_bool_t dbus_message_iter_next (DBusMessageIter *iter);
-int dbus_message_iter_get_arg_type (DBusMessageIter *iter);
-int dbus_message_iter_get_int32 (DBusMessageIter *iter);
-int dbus_message_iter_get_uint32 (DBusMessageIter *iter);
-double dbus_message_iter_get_double (DBusMessageIter *iter);
-char * dbus_message_iter_get_string (DBusMessageIter *iter);
-dbus_bool_t dbus_message_iter_get_int32_array (DBusMessageIter *iter,
- dbus_int32_t **value,
- int *len);
-dbus_bool_t dbus_message_iter_get_uint32_array (DBusMessageIter *iter,
- dbus_uint32_t **value,
- int *len);
-dbus_bool_t dbus_message_iter_get_double_array (DBusMessageIter *iter,
- double **value,
- int *len);
-dbus_bool_t dbus_message_iter_get_byte_array (DBusMessageIter *iter,
- unsigned char **value,
- int *len);
-dbus_bool_t dbus_message_iter_get_string_array (DBusMessageIter *iter,
- char ***value,
- int *len);
+void dbus_message_iter_ref (DBusMessageIter *iter);
+void dbus_message_iter_unref (DBusMessageIter *iter);
+dbus_bool_t dbus_message_iter_has_next (DBusMessageIter *iter);
+dbus_bool_t dbus_message_iter_next (DBusMessageIter *iter);
+int dbus_message_iter_get_arg_type (DBusMessageIter *iter);
+unsigned char dbus_message_iter_get_boolean (DBusMessageIter *iter);
+int dbus_message_iter_get_int32 (DBusMessageIter *iter);
+int dbus_message_iter_get_uint32 (DBusMessageIter *iter);
+double dbus_message_iter_get_double (DBusMessageIter *iter);
+char * dbus_message_iter_get_string (DBusMessageIter *iter);
+dbus_bool_t dbus_message_iter_get_boolean_array (DBusMessageIter *iter,
+ unsigned char **value,
+ int *len);
+dbus_bool_t dbus_message_iter_get_int32_array (DBusMessageIter *iter,
+ dbus_int32_t **value,
+ int *len);
+dbus_bool_t dbus_message_iter_get_uint32_array (DBusMessageIter *iter,
+ dbus_uint32_t **value,
+ int *len);
+dbus_bool_t dbus_message_iter_get_double_array (DBusMessageIter *iter,
+ double **value,
+ int *len);
+dbus_bool_t dbus_message_iter_get_byte_array (DBusMessageIter *iter,
+ unsigned char **value,
+ int *len);
+dbus_bool_t dbus_message_iter_get_string_array (DBusMessageIter *iter,
+ char ***value,
+ int *len);
DBUS_END_DECLS;
/* Data types */
#define DBUS_TYPE_INVALID 0
#define DBUS_TYPE_NIL 1
-#define DBUS_TYPE_INT32 2
-#define DBUS_TYPE_UINT32 3
-#define DBUS_TYPE_DOUBLE 4
-#define DBUS_TYPE_STRING 5
-#define DBUS_TYPE_INT32_ARRAY 6
-#define DBUS_TYPE_UINT32_ARRAY 7
-#define DBUS_TYPE_DOUBLE_ARRAY 8
-#define DBUS_TYPE_BYTE_ARRAY 9
-#define DBUS_TYPE_STRING_ARRAY 10
+#define DBUS_TYPE_BOOLEAN 2
+#define DBUS_TYPE_INT32 3
+#define DBUS_TYPE_UINT32 4
+#define DBUS_TYPE_DOUBLE 5
+#define DBUS_TYPE_STRING 6
+#define DBUS_TYPE_BOOLEAN_ARRAY 7
+#define DBUS_TYPE_INT32_ARRAY 8
+#define DBUS_TYPE_UINT32_ARRAY 9
+#define DBUS_TYPE_DOUBLE_ARRAY 10
+#define DBUS_TYPE_BYTE_ARRAY 11
+#define DBUS_TYPE_STRING_ARRAY 12
/* Header flags */
#define DBUS_HEADER_FLAG_ERROR 0x1
[FIXME perhaps we should add type BYTE with the primary
advantage being that it occupies 1 byte vs. 7 for UINT32,
or perhaps space savings aren't worth the complexity]
- [FIXME perhaps we should add type BOOL with the primary
- advantage being better type safety vs. overloading of
- UINT32]
- The type codes are as follows:
<informaltable>
<tgroup cols=3>
<thead>
<entry>1</entry>
<entry>Marks an "unset" or "nonexistent" argument</entry>
</row><row>
+ <entry>BOOLEAN</entry>
+ <entry>2</entry>
+ <entry>Boolean value, 0 is FALSE and everything else is TRUE.</entry>
+ </row><row>
<entry>INT32</entry>
- <entry>2</entry>
+ <entry>3</entry>
<entry>32-bit signed integer</entry>
</row><row>
<entry>UINT32</entry>
- <entry>3</entry>
+ <entry>4</entry>
<entry>32-bit unsigned integer</entry>
</row><row>
<entry>DOUBLE</entry>
- <entry>4</entry>
+ <entry>5</entry>
<entry>IEEE 754 double</entry>
</row><row>
<entry>STRING</entry>
- <entry>5</entry>
+ <entry>6</entry>
<entry>UTF-8 string (<emphasis>must</emphasis> be valid UTF-8)</entry>
</row><row>
+ <entry>BOOLEAN_ARRAY</entry>
+ <entry>7</entry>
+ <entry>Array of BOOLEAN</entry>
+ </row><row>
<entry>INT32_ARRAY</entry>
<entry>6</entry>
<entry>Array of INT32</entry>
DOUBLE 3.141592653589
TYPE STRING
STRING 'This is a string'
+TYPE BOOLEAN_ARRAY
+BOOLEAN_ARRAY { true, false, false, true, false }
TYPE INT32_ARRAY
INT32_ARRAY { 1, -2, 3, -4, 5, -6, 7, -8, 9, -10 }
TYPE UINT32_ARRAY
projects / platform / upstream / dbus.git / commitdiff