#include <string.h>
+/**
+ * @defgroup DBusMarshal marshaling and unmarshaling
+ * @ingroup DBusInternals
+ * @brief functions to marshal/unmarshal data from the wire
+ *
+ * Types and functions related to converting primitive data types from
+ * wire format to native machine format, and vice versa.
+ *
+ * @{
+ */
+
+static dbus_uint32_t
+unpack_4_octets (int byte_order,
+ const unsigned char *data)
+{
+ _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
+
+ if (byte_order == DBUS_LITTLE_ENDIAN)
+ return DBUS_UINT32_FROM_LE (*(dbus_uint32_t*)data);
+ else
+ return DBUS_UINT32_FROM_BE (*(dbus_uint32_t*)data);
+}
+
+#ifndef DBUS_HAVE_INT64
/* from ORBit */
static void
swap_bytes (unsigned char *data,
++p1;
}
}
+#endif /* !DBUS_HAVE_INT64 */
-/**
- * @defgroup DBusMarshal marshaling and unmarshaling
- * @ingroup DBusInternals
- * @brief functions to marshal/unmarshal data from the wire
- *
- * Types and functions related to converting primitive data types from
- * wire format to native machine format, and vice versa.
- *
- * @{
- */
+typedef union
+{
+#ifdef DBUS_HAVE_INT64
+ dbus_int64_t s;
+ dbus_uint64_t u;
+#endif
+ double d;
+} DBusOctets8;
+
+static DBusOctets8
+unpack_8_octets (int byte_order,
+ const unsigned char *data)
+{
+ DBusOctets8 r;
+
+ _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
+ _dbus_assert (sizeof (r) == 8);
+
+#ifdef DBUS_HAVE_INT64
+ if (byte_order == DBUS_LITTLE_ENDIAN)
+ r.u = DBUS_UINT64_FROM_LE (*(dbus_uint64_t*)data);
+ else
+ r.u = DBUS_UINT64_FROM_BE (*(dbus_uint64_t*)data);
+#else
+ r.d = *(double*)data;
+ swap_bytes (&r, sizeof (r));
+#endif
+
+ return r;
+}
/**
* Unpacks a 32 bit unsigned integer from a data pointer
_dbus_unpack_uint32 (int byte_order,
const unsigned char *data)
{
- _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
-
- if (byte_order == DBUS_LITTLE_ENDIAN)
- return DBUS_UINT32_FROM_LE (*(dbus_uint32_t*)data);
- else
- return DBUS_UINT32_FROM_BE (*(dbus_uint32_t*)data);
+ return unpack_4_octets (byte_order, data);
}
/**
_dbus_unpack_int32 (int byte_order,
const unsigned char *data)
{
+ return (dbus_int32_t) unpack_4_octets (byte_order, data);
+}
+
+#ifdef DBUS_HAVE_INT64
+/**
+ * Unpacks a 64 bit unsigned integer from a data pointer
+ *
+ * @param byte_order The byte order to use
+ * @param data the data pointer
+ * @returns the integer
+ */
+dbus_uint64_t
+_dbus_unpack_uint64 (int byte_order,
+ const unsigned char *data)
+{
+ DBusOctets8 r;
+
+ r = unpack_8_octets (byte_order, data);
+
+ return r.u;
+}
+
+/**
+ * Unpacks a 64 bit signed integer from a data pointer
+ *
+ * @param byte_order The byte order to use
+ * @param data the data pointer
+ * @returns the integer
+ */
+dbus_int64_t
+_dbus_unpack_int64 (int byte_order,
+ const unsigned char *data)
+{
+ DBusOctets8 r;
+
+ r = unpack_8_octets (byte_order, data);
+
+ return r.s;
+}
+
+#endif /* DBUS_HAVE_INT64 */
+
+static void
+pack_4_octets (dbus_uint32_t value,
+ int byte_order,
+ unsigned char *data)
+{
_dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
- if (byte_order == DBUS_LITTLE_ENDIAN)
- return DBUS_INT32_FROM_LE (*(dbus_int32_t*)data);
+ if ((byte_order) == DBUS_LITTLE_ENDIAN)
+ *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_LE (value);
else
- return DBUS_INT32_FROM_BE (*(dbus_int32_t*)data);
+ *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_BE (value);
+}
+
+static void
+pack_8_octets (DBusOctets8 value,
+ int byte_order,
+ unsigned char *data)
+{
+ _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 8) == data);
+
+#ifdef DBUS_HAVE_INT64
+ if ((byte_order) == DBUS_LITTLE_ENDIAN)
+ *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_LE (value.u);
+ else
+ *((dbus_uint64_t*)(data)) = DBUS_UINT64_TO_BE (value.u);
+#else
+ memcpy (data, &value, 8);
+ if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+ swap_bytes ((unsigned char *)data, 8);
+#endif
}
/**
int byte_order,
unsigned char *data)
{
- _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
-
- if ((byte_order) == DBUS_LITTLE_ENDIAN)
- *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_LE (value);
- else
- *((dbus_uint32_t*)(data)) = DBUS_UINT32_TO_BE (value);
+ pack_4_octets (value, byte_order, data);
}
/**
int byte_order,
unsigned char *data)
{
- _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
+ pack_4_octets ((dbus_uint32_t) value, byte_order, data);
+}
+
+#ifdef DBUS_HAVE_INT64
+/**
+ * Packs a 64 bit unsigned integer into a data pointer.
+ *
+ * @param value the value
+ * @param byte_order the byte order to use
+ * @param data the data pointer
+ */
+void
+_dbus_pack_uint64 (dbus_uint64_t value,
+ int byte_order,
+ unsigned char *data)
+{
+ DBusOctets8 r;
+ r.u = value;
+ pack_8_octets (r, byte_order, data);
+}
+
+/**
+ * Packs a 64 bit signed integer into a data pointer.
+ *
+ * @param value the value
+ * @param byte_order the byte order to use
+ * @param data the data pointer
+ */
+void
+_dbus_pack_int64 (dbus_int64_t value,
+ int byte_order,
+ unsigned char *data)
+{
+ DBusOctets8 r;
+ r.s = value;
+ pack_8_octets (r, byte_order, data);
+}
+#endif /* DBUS_HAVE_INT64 */
+
+static void
+set_4_octets (DBusString *str,
+ int byte_order,
+ int offset,
+ dbus_uint32_t value)
+{
+ char *data;
- if ((byte_order) == DBUS_LITTLE_ENDIAN)
- *((dbus_int32_t*)(data)) = DBUS_INT32_TO_LE (value);
- else
- *((dbus_int32_t*)(data)) = DBUS_INT32_TO_BE (value);
+ _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
+ byte_order == DBUS_BIG_ENDIAN);
+
+ data = _dbus_string_get_data_len (str, offset, 4);
+
+ _dbus_pack_uint32 (value, byte_order, data);
+}
+
+static void
+set_8_octets (DBusString *str,
+ int byte_order,
+ int offset,
+ DBusOctets8 value)
+{
+ char *data;
+
+ _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
+ byte_order == DBUS_BIG_ENDIAN);
+
+ data = _dbus_string_get_data_len (str, offset, 8);
+
+ pack_8_octets (value, byte_order, data);
}
/**
int offset,
dbus_int32_t value)
{
- char *data;
-
- _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
- byte_order == DBUS_BIG_ENDIAN);
-
- data = _dbus_string_get_data_len (str, offset, 4);
-
- _dbus_pack_int32 (value, byte_order, data);
+ set_4_octets (str, byte_order, offset, (dbus_uint32_t) value);
}
/**
int offset,
dbus_uint32_t value)
{
- char *data;
-
- _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
- byte_order == DBUS_BIG_ENDIAN);
-
- data = _dbus_string_get_data_len (str, offset, 4);
+ set_4_octets (str, byte_order, offset, value);
+}
- _dbus_pack_uint32 (value, byte_order, data);
+#ifdef DBUS_HAVE_INT64
+
+/**
+ * Sets the 4 bytes at the given offset to a marshaled signed integer,
+ * replacing anything found there previously.
+ *
+ * @param str the string to write the marshalled int to
+ * @param offset the byte offset where int should be written
+ * @param byte_order the byte order to use
+ * @param value the value
+ *
+ */
+void
+_dbus_marshal_set_int64 (DBusString *str,
+ int byte_order,
+ int offset,
+ dbus_int64_t value)
+{
+ DBusOctets8 r;
+ r.s = value;
+ set_8_octets (str, byte_order, offset, r);
}
/**
+ * Sets the 4 bytes at the given offset to a marshaled unsigned
+ * integer, replacing anything found there previously.
+ *
+ * @param str the string to write the marshalled int to
+ * @param offset the byte offset where int should be written
+ * @param byte_order the byte order to use
+ * @param value the value
+ *
+ */
+void
+_dbus_marshal_set_uint64 (DBusString *str,
+ int byte_order,
+ int offset,
+ dbus_uint64_t value)
+{
+ DBusOctets8 r;
+ r.u = value;
+ set_8_octets (str, byte_order, offset, r);
+}
+#endif /* DBUS_HAVE_INT64 */
+
+/**
* Sets the existing marshaled string at the given offset with
* a new marshaled string. The given offset must point to
* an existing string or the wrong length will be deleted
return TRUE;
}
+static dbus_bool_t
+marshal_4_octets (DBusString *str,
+ int byte_order,
+ dbus_uint32_t value)
+{
+ _dbus_assert (sizeof (value) == 4);
+
+ if (!_dbus_string_align_length (str, sizeof (dbus_uint32_t)))
+ return FALSE;
+
+ if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+ value = DBUS_UINT32_SWAP_LE_BE (value);
+
+ return _dbus_string_append_len (str, (const char *)&value, sizeof (dbus_uint32_t));
+}
+
+static dbus_bool_t
+marshal_8_octets (DBusString *str,
+ int byte_order,
+ DBusOctets8 value)
+{
+ _dbus_assert (sizeof (value) == 8);
+
+ if (!_dbus_string_align_length (str, 8))
+ return FALSE;
+
+ if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+ pack_8_octets (value, byte_order, (unsigned char*) &value); /* pack into self, swapping as we go */
+
+ return _dbus_string_append_len (str, (const char *)&value, 8);
+}
+
/**
* Marshals a double value.
*
int byte_order,
double value)
{
- _dbus_assert (sizeof (double) == 8);
-
- if (!_dbus_string_align_length (str, sizeof (double)))
- return FALSE;
-
- if (byte_order != DBUS_COMPILER_BYTE_ORDER)
- swap_bytes ((unsigned char *)&value, sizeof (double));
-
- return _dbus_string_append_len (str, (const char *)&value, sizeof (double));
+ DBusOctets8 r;
+ r.d = value;
+ return marshal_8_octets (str, byte_order, r);
}
/**
int byte_order,
dbus_int32_t value)
{
- if (!_dbus_string_align_length (str, sizeof (dbus_int32_t)))
- return FALSE;
-
- if (byte_order != DBUS_COMPILER_BYTE_ORDER)
- value = DBUS_INT32_SWAP_LE_BE (value);
-
- return _dbus_string_append_len (str, (const char *)&value, sizeof (dbus_int32_t));
+ return marshal_4_octets (str, byte_order, (dbus_uint32_t) value);
}
/**
int byte_order,
dbus_uint32_t value)
{
- if (!_dbus_string_align_length (str, sizeof (dbus_uint32_t)))
- return FALSE;
-
- if (byte_order != DBUS_COMPILER_BYTE_ORDER)
- value = DBUS_UINT32_SWAP_LE_BE (value);
+ return marshal_4_octets (str, byte_order, value);
+}
- return _dbus_string_append_len (str, (const char *)&value, sizeof (dbus_uint32_t));
+
+#ifdef DBUS_HAVE_INT64
+/**
+ * Marshals a 64 bit signed integer value.
+ *
+ * @param str the string to append the marshalled value to
+ * @param byte_order the byte order to use
+ * @param value the value
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+_dbus_marshal_int64 (DBusString *str,
+ int byte_order,
+ dbus_int64_t value)
+{
+ DBusOctets8 r;
+ r.s = value;
+ return marshal_8_octets (str, byte_order, r);
+}
+
+/**
+ * Marshals a 64 bit unsigned integer value.
+ *
+ * @param str the string to append the marshalled value to
+ * @param byte_order the byte order to use
+ * @param value the value
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+_dbus_marshal_uint64 (DBusString *str,
+ int byte_order,
+ dbus_uint64_t value)
+{
+ DBusOctets8 r;
+ r.u = value;
+ return marshal_8_octets (str, byte_order, r);
}
+#endif /* DBUS_HAVE_INT64 */
+
/**
* Marshals a UTF-8 string
*
return _dbus_string_append_len (str, value, len);
}
+static dbus_bool_t
+marshal_4_octets_array (DBusString *str,
+ int byte_order,
+ const dbus_uint32_t *value,
+ int len)
+{
+ int old_string_len;
+ int array_start;
+
+ old_string_len = _dbus_string_get_length (str);
+
+ if (!_dbus_marshal_uint32 (str, byte_order, len * 4))
+ goto error;
+
+ array_start = _dbus_string_get_length (str);
+
+ if (!_dbus_string_append_len (str, (const unsigned char*) value,
+ len * 4))
+ goto error;
+
+ if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+ {
+ const unsigned char *d;
+ const unsigned char *end;
+
+ d = _dbus_string_get_data (str) + array_start;
+ end = d + len * 4;
+ while (d != end)
+ {
+ *((dbus_uint32_t*)d) = DBUS_UINT32_SWAP_LE_BE (*((dbus_uint32_t*)d));
+ d += 4;
+ }
+ }
+
+ return TRUE;
+
+ error:
+ /* Restore previous length */
+ _dbus_string_set_length (str, old_string_len);
+
+ return FALSE;
+}
+
+static dbus_bool_t
+marshal_8_octets_array (DBusString *str,
+ int byte_order,
+ const DBusOctets8 *value,
+ int len)
+{
+ int old_string_len;
+ int array_start;
+
+ old_string_len = _dbus_string_get_length (str);
+
+ if (!_dbus_marshal_uint32 (str, byte_order, len * 8))
+ goto error;
+
+ array_start = _dbus_string_get_length (str);
+
+ if (!_dbus_string_append_len (str, (const unsigned char*) value,
+ len * 8))
+ goto error;
+
+ if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+ {
+ const unsigned char *d;
+ const unsigned char *end;
+
+ d = _dbus_string_get_data (str) + array_start;
+ end = d + len * 8;
+ while (d != end)
+ {
+#ifdef DBUS_HAVE_INT64
+ *((dbus_uint64_t*)d) = DBUS_UINT64_SWAP_LE_BE (*((dbus_uint64_t*)d));
+#else
+ swap_bytes (d, 8);
+#endif
+ d += 8;
+ }
+ }
+
+ return TRUE;
+
+ error:
+ /* Restore previous length */
+ _dbus_string_set_length (str, old_string_len);
+
+ return FALSE;
+}
+
/**
* Marshals a 32 bit signed integer array
*
const dbus_int32_t *value,
int len)
{
- int i, old_string_len;
-
- old_string_len = _dbus_string_get_length (str);
-
- if (!_dbus_marshal_uint32 (str, byte_order, len * sizeof (dbus_int32_t)))
- goto error;
-
- for (i = 0; i < len; i++)
- if (!_dbus_marshal_int32 (str, byte_order, value[i]))
- goto error;
-
- return TRUE;
-
- error:
- /* Restore previous length */
- _dbus_string_set_length (str, old_string_len);
-
- return FALSE;
+ return marshal_4_octets_array (str, byte_order,
+ (const dbus_uint32_t*) value,
+ len);
}
/**
const dbus_uint32_t *value,
int len)
{
- int i, old_string_len;
+ return marshal_4_octets_array (str, byte_order,
+ value,
+ len);
+}
- old_string_len = _dbus_string_get_length (str);
+#ifdef DBUS_HAVE_INT64
- if (!_dbus_marshal_uint32 (str, byte_order, len * sizeof (dbus_uint32_t)))
- goto error;
-
- for (i = 0; i < len; i++)
- if (!_dbus_marshal_uint32 (str, byte_order, value[i]))
- goto error;
+/**
+ * Marshals a 64 bit signed integer array
+ *
+ * @param str the string to append the marshalled value to
+ * @param byte_order the byte order to use
+ * @param value the array
+ * @param len the length of the array
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+_dbus_marshal_int64_array (DBusString *str,
+ int byte_order,
+ const dbus_int64_t *value,
+ int len)
+{
+ return marshal_8_octets_array (str, byte_order,
+ (const DBusOctets8*) value,
+ len);
+}
- return TRUE;
-
- error:
- /* Restore previous length */
- _dbus_string_set_length (str, old_string_len);
-
- return FALSE;
+/**
+ * Marshals a 64 bit unsigned integer array
+ *
+ * @param str the string to append the marshalled value to
+ * @param byte_order the byte order to use
+ * @param value the array
+ * @param len the length of the array
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+_dbus_marshal_uint64_array (DBusString *str,
+ int byte_order,
+ const dbus_uint64_t *value,
+ int len)
+{
+ return marshal_8_octets_array (str, byte_order,
+ (const DBusOctets8*) value,
+ len);
}
+#endif /* DBUS_HAVE_INT64 */
+
/**
* Marshals a double array
*
const double *value,
int len)
{
- int i, old_string_len, array_start;
-
- old_string_len = _dbus_string_get_length (str);
-
- /* Set the length to 0 temporarily */
- if (!_dbus_marshal_uint32 (str, byte_order, 0))
- goto error;
-
- array_start = _dbus_string_get_length (str);
-
- for (i = 0; i < len; i++)
- if (!_dbus_marshal_double (str, byte_order, value[i]))
- goto error;
-
- /* Write the length now that we know it */
- _dbus_marshal_set_uint32 (str, byte_order,
- _DBUS_ALIGN_VALUE (old_string_len, sizeof(dbus_uint32_t)),
- _dbus_string_get_length (str) - array_start);
-
- return TRUE;
-
- error:
- /* Restore previous length */
- _dbus_string_set_length (str, old_string_len);
-
- return FALSE;
+ return marshal_8_octets_array (str, byte_order,
+ (const DBusOctets8*) value,
+ len);
}
/**
return FALSE;
}
-
+static dbus_uint32_t
+demarshal_4_octets (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos)
+{
+ const DBusRealString *real = (const DBusRealString*) str;
+
+ pos = _DBUS_ALIGN_VALUE (pos, 4);
+
+ if (new_pos)
+ *new_pos = pos + 4;
+
+ return unpack_4_octets (byte_order, real->str + pos);
+}
+
+static DBusOctets8
+demarshal_8_octets (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos)
+{
+ const DBusRealString *real = (const DBusRealString*) str;
+
+ pos = _DBUS_ALIGN_VALUE (pos, 8);
+
+ if (new_pos)
+ *new_pos = pos + 8;
+
+ return unpack_8_octets (byte_order, real->str + pos);
+}
+
+/**
+ * Demarshals a double.
+ *
+ * @param str the string containing the data
+ * @param byte_order the byte order
+ * @param pos the position in the string
+ * @param new_pos the new position of the string
+ * @returns the demarshaled double.
+ */
+double
+_dbus_demarshal_double (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos)
+{
+ DBusOctets8 r;
+
+ r = demarshal_8_octets (str, byte_order, pos, new_pos);
+
+ return r.d;
+}
+
+/**
+ * Demarshals a 32 bit signed integer.
+ *
+ * @param str the string containing the data
+ * @param byte_order the byte order
+ * @param pos the position in the string
+ * @param new_pos the new position of the string
+ * @returns the demarshaled integer.
+ */
+dbus_int32_t
+_dbus_demarshal_int32 (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos)
+{
+ return (dbus_int32_t) demarshal_4_octets (str, byte_order, pos, new_pos);
+}
+
/**
- * Demarshals a double.
+ * Demarshals a 32 bit unsigned integer.
*
* @param str the string containing the data
* @param byte_order the byte order
* @param pos the position in the string
* @param new_pos the new position of the string
- * @returns the demarshaled double.
+ * @returns the demarshaled integer.
*/
-double
-_dbus_demarshal_double (const DBusString *str,
- int byte_order,
- int pos,
- int *new_pos)
+dbus_uint32_t
+_dbus_demarshal_uint32 (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos)
{
- double retval;
- const char *buffer;
-
- pos = _DBUS_ALIGN_VALUE (pos, sizeof (double));
-
- buffer = _dbus_string_get_const_data_len (str, pos, sizeof (double));
-
- retval = *(double *)buffer;
-
- if (byte_order != DBUS_COMPILER_BYTE_ORDER)
- swap_bytes ((unsigned char *)&retval, sizeof (double));
-
- if (new_pos)
- *new_pos = pos + sizeof (double);
-
- return retval;
+ return demarshal_4_octets (str, byte_order, pos, new_pos);
}
+#ifdef DBUS_HAVE_INT64
+
/**
- * Demarshals a 32 bit signed integer.
+ * Demarshals a 64 bit signed integer.
*
* @param str the string containing the data
* @param byte_order the byte order
* @param new_pos the new position of the string
* @returns the demarshaled integer.
*/
-dbus_int32_t
-_dbus_demarshal_int32 (const DBusString *str,
+dbus_int64_t
+_dbus_demarshal_int64 (const DBusString *str,
int byte_order,
int pos,
int *new_pos)
{
- const DBusRealString *real = (const DBusRealString*) str;
-
- pos = _DBUS_ALIGN_VALUE (pos, sizeof (dbus_int32_t));
-
- if (new_pos)
- *new_pos = pos + sizeof (dbus_int32_t);
+ DBusOctets8 r;
- if (byte_order == DBUS_LITTLE_ENDIAN)
- return DBUS_INT32_FROM_LE (*(dbus_int32_t*)(real->str + pos));
- else
- return DBUS_INT32_FROM_BE (*(dbus_int32_t*)(real->str + pos));
+ r = demarshal_8_octets (str, byte_order, pos, new_pos);
+
+ return r.s;
}
/**
- * Demarshals a 32 bit unsigned integer.
+ * Demarshals a 64 bit unsigned integer.
*
* @param str the string containing the data
* @param byte_order the byte order
* @param new_pos the new position of the string
* @returns the demarshaled integer.
*/
-dbus_uint32_t
-_dbus_demarshal_uint32 (const DBusString *str,
+dbus_uint64_t
+_dbus_demarshal_uint64 (const DBusString *str,
int byte_order,
int pos,
int *new_pos)
{
- const DBusRealString *real = (const DBusRealString*) str;
-
- pos = _DBUS_ALIGN_VALUE (pos, sizeof (dbus_uint32_t));
-
- if (new_pos)
- *new_pos = pos + sizeof (dbus_uint32_t);
+ DBusOctets8 r;
- if (byte_order == DBUS_LITTLE_ENDIAN)
- return DBUS_UINT32_FROM_LE (*(dbus_uint32_t*)(real->str + pos));
- else
- return DBUS_UINT32_FROM_BE (*(dbus_uint32_t*)(real->str + pos));
+ r = demarshal_8_octets (str, byte_order, pos, new_pos);
+
+ return r.u;
}
+#endif /* DBUS_HAVE_INT64 */
+
/**
* Demarshals an UTF-8 string.
*
return TRUE;
}
-/**
- * Demarshals a 32 bit signed integer array.
- *
- * @param str the string containing the data
- * @param byte_order the byte order
- * @param pos the position in the string
- * @param new_pos the new position of the string
- * @param array the array
- * @param array_len length of the demarshaled data
- * @returns #TRUE on success
- */
-dbus_bool_t
-_dbus_demarshal_int32_array (const DBusString *str,
- int byte_order,
- int pos,
- int *new_pos,
- dbus_int32_t **array,
- int *array_len)
+static dbus_bool_t
+demarshal_4_octets_array (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos,
+ dbus_uint32_t **array,
+ int *array_len)
{
int len, i;
- dbus_int32_t *retval;
+ dbus_uint32_t *retval;
+ int byte_len;
- len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos) / sizeof (dbus_int32_t);
+ byte_len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos);
+ len = byte_len / 4;
if (len == 0)
{
return TRUE;
}
-
- retval = dbus_new (dbus_int32_t, len);
-
- if (!retval)
- return FALSE;
- for (i = 0; i < len; i++)
- retval[i] = _dbus_demarshal_int32 (str, byte_order, pos, &pos);
+ if (!_dbus_string_copy_data_len (str, (char**) &retval,
+ pos, byte_len))
+ return FALSE;
+
+ if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+ {
+ for (i = 0; i < len; i++)
+ retval[i] = DBUS_UINT32_SWAP_LE_BE (retval[i]);
+ }
if (new_pos)
- *new_pos = pos;
+ *new_pos = pos + byte_len;
*array_len = len;
*array = retval;
- return TRUE;
+ return TRUE;
}
-/**
- * Demarshals a 32 bit unsigned integer array.
- *
- * @param str the string containing the data
- * @param byte_order the byte order
- * @param pos the position in the string
- * @param new_pos the new position of the string
- * @param array the array
- * @param array_len length of the demarshaled data
- * @returns #TRUE on success
- */
-dbus_bool_t
-_dbus_demarshal_uint32_array (const DBusString *str,
- int byte_order,
- int pos,
- int *new_pos,
- dbus_uint32_t **array,
- int *array_len)
+static dbus_bool_t
+demarshal_8_octets_array (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos,
+ DBusOctets8 **array,
+ int *array_len)
{
int len, i;
- dbus_uint32_t *retval;
+ DBusOctets8 *retval;
+ int byte_len;
- len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos) / sizeof (dbus_uint32_t);
+ byte_len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos);
+ len = byte_len / 8;
if (len == 0)
{
return TRUE;
}
-
- retval = dbus_new (dbus_uint32_t, len);
- if (!retval)
+ if (!_dbus_string_copy_data_len (str, (char**) &retval,
+ pos, byte_len))
return FALSE;
-
- for (i = 0; i < len; i++)
- retval[i] = _dbus_demarshal_uint32 (str, byte_order, pos, &pos);
+
+ if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+ {
+ for (i = 0; i < len; i++)
+ {
+#ifdef DBUS_HAVE_INT64
+ retval[i].u = DBUS_UINT64_SWAP_LE_BE (retval[i].u);
+#else
+ swap_bytes (&retval[i], 8);
+#endif
+ }
+ }
if (new_pos)
- *new_pos = pos;
+ *new_pos = pos + byte_len;
*array_len = len;
*array = retval;
}
/**
- * Demarshals a double array.
+ * Demarshals a 32 bit signed integer array.
*
* @param str the string containing the data
* @param byte_order the byte order
* @returns #TRUE on success
*/
dbus_bool_t
-_dbus_demarshal_double_array (const DBusString *str,
+_dbus_demarshal_int32_array (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos,
+ dbus_int32_t **array,
+ int *array_len)
+{
+ return demarshal_4_octets_array (str, byte_order, pos, new_pos,
+ (dbus_uint32_t**) array, array_len);
+}
+
+/**
+ * Demarshals a 32 bit unsigned integer array.
+ *
+ * @param str the string containing the data
+ * @param byte_order the byte order
+ * @param pos the position in the string
+ * @param new_pos the new position of the string
+ * @param array the array
+ * @param array_len length of the demarshaled data
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+_dbus_demarshal_uint32_array (const DBusString *str,
int byte_order,
int pos,
int *new_pos,
- double **array,
+ dbus_uint32_t **array,
int *array_len)
{
- int len, i;
- double *retval;
-
- len = _dbus_demarshal_uint32 (str, byte_order, pos, &pos) / sizeof (double);
-
- if (len == 0)
- {
- *array_len = 0;
- *array = NULL;
+ return demarshal_4_octets_array (str, byte_order, pos, new_pos,
+ array, array_len);
+}
- if (new_pos)
- *new_pos = pos;
-
- return TRUE;
- }
-
- retval = dbus_new (double, len);
+#ifdef DBUS_HAVE_INT64
- if (!retval)
- return FALSE;
+/**
+ * Demarshals a 64 bit signed integer array.
+ *
+ * @param str the string containing the data
+ * @param byte_order the byte order
+ * @param pos the position in the string
+ * @param new_pos the new position of the string
+ * @param array the array
+ * @param array_len length of the demarshaled data
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+_dbus_demarshal_int64_array (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos,
+ dbus_int64_t **array,
+ int *array_len)
+{
+ return demarshal_8_octets_array (str, byte_order, pos, new_pos,
+ (DBusOctets8**) array, array_len);
+}
- for (i = 0; i < len; i++)
- retval[i] = _dbus_demarshal_double (str, byte_order, pos, &pos);
+/**
+ * Demarshals a 64 bit unsigned integer array.
+ *
+ * @param str the string containing the data
+ * @param byte_order the byte order
+ * @param pos the position in the string
+ * @param new_pos the new position of the string
+ * @param array the array
+ * @param array_len length of the demarshaled data
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+_dbus_demarshal_uint64_array (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos,
+ dbus_uint64_t **array,
+ int *array_len)
+{
+ return demarshal_8_octets_array (str, byte_order, pos, new_pos,
+ (DBusOctets8**) array, array_len);
+}
- if (new_pos)
- *new_pos = pos;
+#endif /* DBUS_HAVE_INT64 */
- *array_len = len;
- *array = retval;
-
- return TRUE;
+/**
+ * Demarshals a double array.
+ *
+ * @param str the string containing the data
+ * @param byte_order the byte order
+ * @param pos the position in the string
+ * @param new_pos the new position of the string
+ * @param array the array
+ * @param array_len length of the demarshaled data
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+_dbus_demarshal_double_array (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos,
+ double **array,
+ int *array_len)
+{
+ return demarshal_8_octets_array (str, byte_order, pos, new_pos,
+ (DBusOctets8**) array, array_len);
}
/**
break;
+#ifdef DBUS_HAVE_INT64
+ case DBUS_TYPE_INT64:
+ *end_pos = _DBUS_ALIGN_VALUE (pos, sizeof (dbus_int64_t)) + sizeof (dbus_int64_t);
+
+ break;
+
+ case DBUS_TYPE_UINT64:
+ *end_pos = _DBUS_ALIGN_VALUE (pos, sizeof (dbus_uint64_t)) + sizeof (dbus_uint64_t);
+
+ break;
+#endif /* DBUS_HAVE_INT64 */
+
case DBUS_TYPE_DOUBLE:
*end_pos = _DBUS_ALIGN_VALUE (pos, sizeof (double)) + sizeof (double);
return FALSE;
}
- *end_pos = pos + 1;
- break;
+ *end_pos = pos + 1;
}
+ break;
+
case DBUS_TYPE_INT32:
case DBUS_TYPE_UINT32:
{
}
break;
+ case DBUS_TYPE_INT64:
+ case DBUS_TYPE_UINT64:
+ {
+ int align_8 = _DBUS_ALIGN_VALUE (pos, 8);
+
+ if (!_dbus_string_validate_nul (str, pos,
+ align_8 - pos))
+ {
+ _dbus_verbose ("int64/uint64 alignment padding not initialized to nul\n");
+ return FALSE;
+ }
+
+ *end_pos = align_8 + 8;
+ }
+ break;
+
case DBUS_TYPE_DOUBLE:
{
int align_8 = _DBUS_ALIGN_VALUE (pos, 8);
{
DBusString str;
char *tmp1, *tmp2;
- dbus_int32_t array1[3] = { 0x123, 0x456, 0x789 }, *array2;
int pos = 0, len;
+ dbus_int32_t array1[3] = { 0x123, 0x456, 0x789 }, *array2;
+#ifdef DBUS_HAVE_INT64
+ dbus_int64_t array3[3] = { 0x123ffffffff, 0x456ffffffff, 0x789ffffffff }, *array4;
+#endif
if (!_dbus_string_init (&str))
_dbus_assert_not_reached ("failed to init string");
if (!_dbus_demarshal_uint32 (&str, DBUS_LITTLE_ENDIAN, pos, &pos) == 0x12345678)
_dbus_assert_not_reached ("demarshal failed");
+#ifdef DBUS_HAVE_INT64
+ /* Marshal signed integers */
+ if (!_dbus_marshal_int64 (&str, DBUS_BIG_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7)))
+ _dbus_assert_not_reached ("could not marshal signed integer value");
+ if (!_dbus_demarshal_int64 (&str, DBUS_BIG_ENDIAN, pos, &pos) == DBUS_INT64_CONSTANT (-0x123456789abc7))
+ _dbus_assert_not_reached ("demarshal failed");
+
+ if (!_dbus_marshal_int64 (&str, DBUS_LITTLE_ENDIAN, DBUS_INT64_CONSTANT (-0x123456789abc7)))
+ _dbus_assert_not_reached ("could not marshal signed integer value");
+ if (!_dbus_demarshal_int64 (&str, DBUS_LITTLE_ENDIAN, pos, &pos) == DBUS_INT64_CONSTANT (-0x123456789abc7))
+ _dbus_assert_not_reached ("demarshal failed");
+
+ /* Marshal unsigned integers */
+ if (!_dbus_marshal_uint64 (&str, DBUS_BIG_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7)))
+ _dbus_assert_not_reached ("could not marshal signed integer value");
+ if (!_dbus_demarshal_uint64 (&str, DBUS_BIG_ENDIAN, pos, &pos) == DBUS_UINT64_CONSTANT (0x123456789abc7))
+ _dbus_assert_not_reached ("demarshal failed");
+
+ if (!_dbus_marshal_uint64 (&str, DBUS_LITTLE_ENDIAN, DBUS_UINT64_CONSTANT (0x123456789abc7)))
+ _dbus_assert_not_reached ("could not marshal signed integer value");
+ if (!_dbus_demarshal_uint64 (&str, DBUS_LITTLE_ENDIAN, pos, &pos) == DBUS_UINT64_CONSTANT (0x123456789abc7))
+ _dbus_assert_not_reached ("demarshal failed");
+#endif /* DBUS_HAVE_INT64 */
+
/* Marshal strings */
tmp1 = "This is the dbus test string";
if (!_dbus_marshal_string (&str, DBUS_BIG_ENDIAN, tmp1))
if (len != 3)
_dbus_assert_not_reached ("Signed integer array lengths differ!\n");
dbus_free (array2);
+
+#ifdef DBUS_HAVE_INT64
+ /* Marshal 64-bit signed integer arrays */
+ if (!_dbus_marshal_int64_array (&str, DBUS_BIG_ENDIAN, array3, 3))
+ _dbus_assert_not_reached ("could not marshal integer array");
+ if (!_dbus_demarshal_int64_array (&str, DBUS_BIG_ENDIAN, pos, &pos, &array4, &len))
+ _dbus_assert_not_reached ("could not demarshal integer array");
+
+ if (len != 3)
+ _dbus_assert_not_reached ("Signed integer array lengths differ!\n");
+ dbus_free (array4);
+#endif
_dbus_string_free (&str);
}
/**
- * Appends fields to a message given a variable argument
- * list. The variable argument list should contain the type
- * of the argument followed by the value to add.
- * Array values are specified by a int typecode followed by a pointer
- * to the array followed by an int giving the length of the array.
- * The argument list must be terminated with 0.
+ * Appends fields to a message given a variable argument list. The
+ * variable argument list should contain the type of the argument
+ * followed by the value to add. Array values are specified by an int
+ * typecode followed by a pointer to the array followed by an int
+ * giving the length of the array. The argument list must be
+ * terminated with DBUS_TYPE_INVALID.
*
* This function doesn't support dicts or non-fundamental arrays.
*
+ * This function supports #DBUS_TYPE_INT64 and #DBUS_TYPE_UINT64
+ * only if #DBUS_HAVE_INT64 is defined.
+ *
* @param message the message
* @param first_arg_type type of the first argument
* @param ... value of first argument, list of additional type-value pairs
}
/**
- * This function takes a va_list for use by language bindings
+ * This function takes a va_list for use by language bindings.
+ * It's otherwise the same as dbus_message_append_args().
*
* @todo: Shouldn't this function clean up the changes to the message
- * on failures?
+ * on failures? (Yes)
* @see dbus_message_append_args.
* @param message the message
if (!dbus_message_iter_append_uint32 (&iter, va_arg (var_args, dbus_uint32_t)))
goto errorout;
break;
+#ifdef DBUS_HAVE_INT64
+ case DBUS_TYPE_INT64:
+ if (!dbus_message_iter_append_int64 (&iter, va_arg (var_args, dbus_int64_t)))
+ goto errorout;
+ break;
+ case DBUS_TYPE_UINT64:
+ if (!dbus_message_iter_append_uint64 (&iter, va_arg (var_args, dbus_uint64_t)))
+ goto errorout;
+ break;
+#endif /* DBUS_HAVE_INT64 */
case DBUS_TYPE_DOUBLE:
if (!dbus_message_iter_append_double (&iter, va_arg (var_args, double)))
goto errorout;
if (!dbus_message_iter_append_uint32_array (&iter, (dbus_uint32_t *)data, len))
goto errorout;
break;
+#ifdef DBUS_HAVE_INT64
+ case DBUS_TYPE_INT64:
+ if (!dbus_message_iter_append_int64_array (&iter, (dbus_int64_t *)data, len))
+ goto errorout;
+ break;
+ case DBUS_TYPE_UINT64:
+ if (!dbus_message_iter_append_uint64_array (&iter, (dbus_uint64_t *)data, len))
+ goto errorout;
+ break;
+#endif /* DBUS_HAVE_INT64 */
case DBUS_TYPE_DOUBLE:
if (!dbus_message_iter_append_double_array (&iter, (double *)data, len))
goto errorout;
/**
* This function takes a va_list for use by language bindings
*
+ * This function supports #DBUS_TYPE_INT64 and #DBUS_TYPE_UINT64
+ * only if #DBUS_HAVE_INT64 is defined.
+ *
* @todo this function (or some lower-level non-convenience function)
* needs better error handling; should allow the application to
* distinguish between out of memory, and bad data from the remote
*ptr = dbus_message_iter_get_uint32 (iter);
break;
}
+#ifdef DBUS_HAVE_INT64
+ case DBUS_TYPE_INT64:
+ {
+ dbus_int64_t *ptr;
+
+ ptr = va_arg (var_args, dbus_int64_t *);
+
+ *ptr = dbus_message_iter_get_int64 (iter);
+ break;
+ }
+ case DBUS_TYPE_UINT64:
+ {
+ dbus_uint64_t *ptr;
+
+ ptr = va_arg (var_args, dbus_uint64_t *);
+ *ptr = dbus_message_iter_get_uint64 (iter);
+ break;
+ }
+#endif /* DBUS_HAVE_INT64 */
+
case DBUS_TYPE_DOUBLE:
{
double *ptr;
goto out;
}
break;
+#ifdef DBUS_HAVE_INT64
+ case DBUS_TYPE_INT64:
+ if (!dbus_message_iter_get_int64_array (iter, (dbus_int64_t **)data, len))
+ {
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ goto out;
+ }
+ break;
+ case DBUS_TYPE_UINT64:
+ if (!dbus_message_iter_get_uint64_array (iter, (dbus_uint64_t **)data, len))
+ {
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ goto out;
+ }
+ break;
+#endif /* DBUS_HAVE_INT64 */
case DBUS_TYPE_DOUBLE:
if (!dbus_message_iter_get_double_array (iter, (double **)data, len))
{
/**
* 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.
+ * a 32-bit integer value before using this function.
*
* @see dbus_message_iter_get_arg_type
* @param iter the message iter
/**
* Returns the 32 bit unsigned integer value that an iterator may point to.
* Note that you need to check that the iterator points to
- * an unsigned integer value before using this function.
+ * a 32-bit unsigned integer value before using this function.
*
* @see dbus_message_iter_get_arg_type
* @param iter the message iter
pos, NULL);
}
+#ifdef DBUS_HAVE_INT64
+
+/**
+ * Returns the 64 bit signed integer value that an iterator may point
+ * to. Note that you need to check that the iterator points to a
+ * 64-bit integer value before using this function.
+ *
+ * This function only exists if #DBUS_HAVE_INT64 is defined.
+ *
+ * @see dbus_message_iter_get_arg_type
+ * @param iter the message iter
+ * @returns the integer
+ */
+dbus_int64_t
+dbus_message_iter_get_int64 (DBusMessageIter *iter)
+{
+ DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
+ int type, pos;
+
+ dbus_message_iter_check (real);
+
+ pos = dbus_message_iter_get_data_start (real, &type);
+
+ _dbus_assert (type == DBUS_TYPE_INT64);
+
+ return _dbus_demarshal_int64 (&real->message->body, real->message->byte_order,
+ pos, NULL);
+}
+
+/**
+ * Returns the 64 bit unsigned integer value that an iterator may point to.
+ * Note that you need to check that the iterator points to
+ * a 64-bit unsigned integer value before using this function.
+ *
+ * This function only exists if #DBUS_HAVE_INT64 is defined.
+ *
+ * @see dbus_message_iter_get_arg_type
+ * @param iter the message iter
+ * @returns the integer
+ */
+dbus_uint64_t
+dbus_message_iter_get_uint64 (DBusMessageIter *iter)
+{
+ DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
+ int type, pos;
+
+ dbus_message_iter_check (real);
+
+ pos = dbus_message_iter_get_data_start (real, &type);
+
+ _dbus_assert (type == DBUS_TYPE_UINT64);
+
+ return _dbus_demarshal_uint64 (&real->message->body, real->message->byte_order,
+ pos, NULL);
+}
+
+#endif /* DBUS_HAVE_INT64 */
+
/**
* Returns the double value that an iterator may point to.
* Note that you need to check that the iterator points to
return TRUE;
}
+#ifdef DBUS_HAVE_INT64
+
+/**
+ * Returns the 64 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.
+ *
+ * This function only exists if #DBUS_HAVE_INT64 is defined.
+ *
+ * @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_int64_array (DBusMessageIter *iter,
+ dbus_int64_t **value,
+ int *len)
+{
+ DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
+ int type, pos;
+
+ dbus_message_iter_check (real);
+
+ pos = dbus_message_iter_get_data_start (real, &type);
+
+ _dbus_assert (type == DBUS_TYPE_ARRAY);
+
+ type = iter_get_array_type (real, NULL);
+
+ _dbus_assert (type == DBUS_TYPE_INT64);
+
+ if (!_dbus_demarshal_int64_array (&real->message->body, real->message->byte_order,
+ pos, NULL, value, len))
+ return FALSE;
+ else
+ return TRUE;
+}
+
+/**
+ * Returns the 64 bit unsigned 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.
+ *
+ * This function only exists if #DBUS_HAVE_INT64 is defined.
+ *
+ * @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_uint64_array (DBusMessageIter *iter,
+ dbus_uint64_t **value,
+ int *len)
+{
+ DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
+ int type, pos;
+
+ dbus_message_iter_check (real);
+
+ pos = dbus_message_iter_get_data_start (real, &type);
+
+ _dbus_assert (type == DBUS_TYPE_ARRAY);
+
+ type = iter_get_array_type (real, NULL);
+ _dbus_assert (type == DBUS_TYPE_UINT64);
+
+ if (!_dbus_demarshal_uint64_array (&real->message->body, real->message->byte_order,
+ pos, NULL, value, len))
+ return FALSE;
+ else
+ return TRUE;
+}
+
+#endif /* DBUS_HAVE_INT64 */
+
/**
* Returns the double array that the iterator may point to. Note that
* you need to check that the iterator points to an array of the
return TRUE;
}
+#ifdef DBUS_HAVE_INT64
+
+/**
+ * Appends a 64 bit signed integer to the message.
+ *
+ * This function only exists if #DBUS_HAVE_INT64 is defined.
+ *
+ * @param iter an iterator pointing to the end of the message
+ * @param value the integer value
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+dbus_message_iter_append_int64 (DBusMessageIter *iter,
+ dbus_int64_t value)
+{
+ DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
+
+ dbus_message_iter_append_check (real);
+
+ if (!dbus_message_iter_append_type (real, DBUS_TYPE_INT64))
+ return FALSE;
+
+ if (!_dbus_marshal_int64 (&real->message->body, real->message->byte_order, value))
+ {
+ _dbus_string_set_length (&real->message->body, real->pos);
+ return FALSE;
+ }
+
+ dbus_message_iter_append_done (real);
+
+ return TRUE;
+}
+
+/**
+ * Appends a 64 bit unsigned integer to the message.
+ *
+ * This function only exists if #DBUS_HAVE_INT64 is defined.
+ *
+ * @param iter an iterator pointing to the end of the message
+ * @param value the integer value
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+dbus_message_iter_append_uint64 (DBusMessageIter *iter,
+ dbus_uint64_t value)
+{
+ DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
+
+ dbus_message_iter_append_check (real);
+
+ if (!dbus_message_iter_append_type (real, DBUS_TYPE_UINT64))
+ return FALSE;
+
+ if (!_dbus_marshal_uint64 (&real->message->body, real->message->byte_order, value))
+ {
+ _dbus_string_set_length (&real->message->body, real->pos);
+ return FALSE;
+ }
+
+ dbus_message_iter_append_done (real);
+
+ return TRUE;
+}
+
+#endif /* DBUS_HAVE_INT64 */
+
/**
* Appends a double value to the message.
*
return TRUE;
}
+#ifdef DBUS_HAVE_INT64
+
+/**
+ * Appends a 64 bit signed integer array to the message.
+ *
+ * This function only exists if #DBUS_HAVE_INT64 is defined.
+ *
+ * @param iter an iterator pointing to the end of the message
+ * @param value the array
+ * @param len the length of the array
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+dbus_message_iter_append_int64_array (DBusMessageIter *iter,
+ const dbus_int64_t *value,
+ int len)
+{
+ DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
+
+ dbus_message_iter_append_check (real);
+
+ if (!append_array_type (real, DBUS_TYPE_INT64, NULL, NULL))
+ return FALSE;
+
+ if (!_dbus_marshal_int64_array (&real->message->body, real->message->byte_order, value, len))
+ {
+ _dbus_string_set_length (&real->message->body, real->pos);
+ return FALSE;
+ }
+
+ dbus_message_iter_append_done (real);
+
+ return TRUE;
+}
+
+/**
+ * Appends a 64 bit unsigned integer array to the message.
+ *
+ * This function only exists if #DBUS_HAVE_INT64 is defined.
+ *
+ * @param iter an iterator pointing to the end of the message
+ * @param value the array
+ * @param len the length of the array
+ * @returns #TRUE on success
+ */
+dbus_bool_t
+dbus_message_iter_append_uint64_array (DBusMessageIter *iter,
+ const dbus_uint64_t *value,
+ int len)
+{
+ DBusMessageRealIter *real = (DBusMessageRealIter *)iter;
+
+ dbus_message_iter_append_check (real);
+
+ if (!append_array_type (real, DBUS_TYPE_UINT64, NULL, NULL))
+ return FALSE;
+
+ if (!_dbus_marshal_uint64_array (&real->message->body, real->message->byte_order, value, len))
+ {
+ _dbus_string_set_length (&real->message->body, real->pos);
+ return FALSE;
+ }
+
+ dbus_message_iter_append_done (real);
+
+ return TRUE;
+}
+#endif /* DBUS_HAVE_INT64 */
+
/**
* Appends a double array to the message.
*
if (type != DBUS_TYPE_STRING)
{
- _dbus_verbose ("%s field has wrong type\n", field_name);
+ _dbus_verbose ("%s field has wrong type %s\n",
+ field_name, _dbus_type_to_string (type));
return FALSE;
}
case DBUS_TYPE_UINT32:
dbus_message_iter_get_uint32 (iter);
break;
+ case DBUS_TYPE_INT64:
+#ifdef DBUS_HAVE_INT64
+ dbus_message_iter_get_int64 (iter);
+#endif
+ break;
+ case DBUS_TYPE_UINT64:
+#ifdef DBUS_HAVE_INT64
+ dbus_message_iter_get_uint64 (iter);
+#endif
+ break;
case DBUS_TYPE_DOUBLE:
dbus_message_iter_get_double (iter);
break;
int our_int_array_len;
DBusMessageIter iter, dict;
DBusError error;
-
+#ifdef DBUS_HAVE_INT64
+ dbus_int64_t our_int64;
+#endif
+
dbus_message_iter_init (message, &iter);
dbus_error_init (&error);
if (!dbus_message_iter_get_args (&iter, &error,
DBUS_TYPE_INT32, &our_int,
+#ifdef DBUS_HAVE_INT64
+ DBUS_TYPE_INT64, &our_int64,
+#endif
DBUS_TYPE_STRING, &our_str,
DBUS_TYPE_DOUBLE, &our_double,
DBUS_TYPE_BOOLEAN, &our_bool,
if (our_int != -0x12345678)
_dbus_assert_not_reached ("integers differ!");
+#ifdef DBUS_HAVE_INT64
+ if (our_int64 != -0x123456789abcd)
+ _dbus_assert_not_reached ("64-bit integers differ!");
+#endif
+
if (our_double != 3.14159)
_dbus_assert_not_reached ("doubles differ!");
_dbus_message_set_serial (message, 1);
dbus_message_append_args (message,
DBUS_TYPE_INT32, -0x12345678,
+#ifdef DBUS_HAVE_INT64
+ DBUS_TYPE_INT64, -0x123456789abcd,
+#endif
DBUS_TYPE_STRING, "Test string",
DBUS_TYPE_DOUBLE, 3.14159,
DBUS_TYPE_BOOLEAN, TRUE,
projects / platform / upstream / dbus.git / commitdiff