summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--ChangeLog13
-rw-r--r--configure.in32
-rw-r--r--dbus-1.0.pc.in2
-rw-r--r--dbus/Makefile.am7
-rw-r--r--dbus/dbus-arch-deps.h.in51
-rw-r--r--dbus/dbus-internals.h11
-rw-r--r--dbus/dbus-marshal.c1009
-rw-r--r--dbus/dbus-marshal.h117
-rw-r--r--dbus/dbus-message-builder.c2
-rw-r--r--dbus/dbus-message.c382
-rw-r--r--dbus/dbus-message.h27
-rw-r--r--dbus/dbus-protocol.h12
-rw-r--r--dbus/dbus.h1
-rw-r--r--doc/dbus-specification.sgml24
-rw-r--r--test/decode-gcov.c2
15 files changed, 1405 insertions, 287 deletions
diff --git a/ChangeLog b/ChangeLog
index 7818e3f9..5d86d0ff 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,18 @@
2003-04-22 Havoc Pennington <hp@redhat.com>
+ * dbus/dbus-message.c, dbus/dbus-marshal.c: add 64-bit integer
+ support, and do some code cleanups to share more code and
+ speed up array marshal/demarshal.
+
+ * dbus-1.0.pc.in (Cflags): put libdir include file in cflags
+
+ * configure.in: generate dbus-arch-deps.h
+
+ * dbus/dbus-protocol.h (DBUS_TYPE_INT64, DBUS_TYPE_UINT64): add
+ 64-bit typecodes
+
+2003-04-22 Havoc Pennington <hp@redhat.com>
+
* test/data/valid-messages/opposite-endian.message: fix test
to use proper type for rply field
diff --git a/configure.in b/configure.in
index 12d8d8ea..faac0553 100644
--- a/configure.in
+++ b/configure.in
@@ -146,23 +146,50 @@ AC_CHECK_SIZEOF(void *)
AC_CHECK_SIZEOF(long long)
AC_CHECK_SIZEOF(__int64)
-### this is only used in decode-gcov.c right now
+### See what our 64 bit type is called
+AC_MSG_CHECKING([64-bit integer type])
+
case 8 in
$ac_cv_sizeof_int)
dbusint64=int
+ dbusint64_constant='(val)'
+ dbusuint64_constant='(val)'
;;
$ac_cv_sizeof_long)
dbusint64=long
+ dbusint64_constant='(val##L)'
+ dbusuint64_constant='(val##UL)'
;;
$ac_cv_sizeof_long_long)
dbusint64='long long'
+ dbusint64_constant='(val##LL)'
+ dbusuint64_constant='(val##ULL)'
;;
$ac_cv_sizeof___int64)
dbusint64=__int64
+ dbusint64_constant='(val##i64)'
+ dbusuint64_constant='(val##ui64)'
;;
esac
-AC_DEFINE_UNQUOTED(DBUS_INT64_TYPE, $dbusint64, [64-bit integer type])
+if test -z "$dbusint64" ; then
+ DBUS_INT64_TYPE="no_int64_type_detected"
+ DBUS_HAVE_INT64=0
+ DBUS_INT64_CONSTANT=
+ DBUS_UINT64_CONSTANT=
+ AC_MSG_RESULT([none found])
+else
+ DBUS_INT64_TYPE="$dbusint64"
+ DBUS_HAVE_INT64=1
+ DBUS_INT64_CONSTANT="$dbusint64_constant"
+ DBUS_UINT64_CONSTANT="$dbusuint64_constant"
+ AC_MSG_RESULT($DBUS_INT64_TYPE)
+fi
+
+AC_SUBST(DBUS_INT64_TYPE)
+AC_SUBST(DBUS_INT64_CONSTANT)
+AC_SUBST(DBUS_UINT64_CONSTANT)
+AC_SUBST(DBUS_HAVE_INT64)
## byte order
AC_C_BIGENDIAN
@@ -521,6 +548,7 @@ bus/session.conf
bus/messagebus
Makefile
dbus/Makefile
+dbus/dbus-arch-deps.h
glib/Makefile
qt/Makefile
bus/Makefile
diff --git a/dbus-1.0.pc.in b/dbus-1.0.pc.in
index 2df0a7cf..1b535ba2 100644
--- a/dbus-1.0.pc.in
+++ b/dbus-1.0.pc.in
@@ -7,5 +7,5 @@ Name: dbus
Description: Free desktop message bus
Version: @VERSION@
Libs: -L${libdir} -ldbus-1
-Cflags: -I${includedir}/dbus-1.0
+Cflags: -I${includedir}/dbus-1.0 -I${libdir}/dbus-1.0/include
diff --git a/dbus/Makefile.am b/dbus/Makefile.am
index 9528b547..8dcb79dd 100644
--- a/dbus/Makefile.am
+++ b/dbus/Makefile.am
@@ -3,6 +3,7 @@ INCLUDES=-I$(top_srcdir) $(DBUS_CLIENT_CFLAGS) -DDBUS_COMPILATION \
-DDBUS_SYSTEM_BUS_PATH=\""@DBUS_SYSTEM_SOCKET@"\"
dbusincludedir=$(includedir)/dbus-1.0/dbus
+dbusarchincludedir=$(libdir)/dbus-1.0/include/dbus
lib_LTLIBRARIES=libdbus-1.la
@@ -21,6 +22,9 @@ dbusinclude_HEADERS= \
dbus-threads.h \
dbus-types.h
+dbusarchinclude_HEADERS= \
+ dbus-arch-deps.h
+
### source code that goes in the installed client library
### and is specific to library functionality
DBUS_LIB_SOURCES= \
@@ -116,6 +120,9 @@ libdbus_convenience_la_SOURCES= \
$(DBUS_SHARED_SOURCES) \
$(DBUS_UTIL_SOURCES)
+BUILT_SOURCES=$(dbusarchinclude_HEADERS)
+EXTRA_DIST=dbus-arch-deps.h.in
+
## this library is the same as libdbus, but exports all the symbols
## and is only used for static linking within the dbus package.
noinst_LTLIBRARIES=libdbus-convenience.la
diff --git a/dbus/dbus-arch-deps.h.in b/dbus/dbus-arch-deps.h.in
new file mode 100644
index 00000000..92e68a75
--- /dev/null
+++ b/dbus/dbus-arch-deps.h.in
@@ -0,0 +1,51 @@
+/* -*- mode: C; c-file-style: "gnu" -*- */
+/* dbus-arch-deps.h Header with architecture/compiler specific information, installed to libdir
+ *
+ * Copyright (C) 2003 Red Hat, Inc.
+ *
+ * Licensed under the Academic Free License version 1.2
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+#if !defined (DBUS_INSIDE_DBUS_H) && !defined (DBUS_COMPILATION)
+#error "Only <dbus/dbus.h> can be included directly, this file may disappear or change contents."
+#endif
+
+#ifndef DBUS_ARCH_DEPS_H
+#define DBUS_ARCH_DEPS_H
+
+#include <dbus/dbus-types.h>
+#include <dbus/dbus-macros.h>
+
+DBUS_BEGIN_DECLS;
+
+#if @DBUS_HAVE_INT64@
+#define DBUS_HAVE_INT64 1
+typedef @DBUS_INT64_TYPE@ dbus_int64_t;
+typedef unsigned @DBUS_INT64_TYPE@ dbus_uint64_t;
+
+#define DBUS_INT64_CONSTANT(val) @DBUS_INT64_CONSTANT@
+#define DBUS_UINT64_CONSTANT(val) @DBUS_UINT64_CONSTANT@
+
+#else
+#undef DBUS_HAVE_INT64
+#undef DBUS_INT64_CONSTANT
+#undef DBUS_UINT64_CONSTANT
+#endif
+
+DBUS_END_DECLS;
+
+#endif /* DBUS_ARCH_DEPS_H */
diff --git a/dbus/dbus-internals.h b/dbus/dbus-internals.h
index 9eac19c9..c99caa74 100644
--- a/dbus/dbus-internals.h
+++ b/dbus/dbus-internals.h
@@ -115,10 +115,13 @@ dbus_bool_t _dbus_string_array_contains (const char **array,
const char *str);
char** _dbus_dup_string_array (const char **array);
-
-#define _DBUS_INT_MIN (-_DBUS_INT_MAX - 1)
-#define _DBUS_INT_MAX 2147483647
-#define _DBUS_UINT_MAX 0xffffffff
+#define _DBUS_INT_MIN (-_DBUS_INT_MAX - 1)
+#define _DBUS_INT_MAX 2147483647
+#define _DBUS_UINT_MAX 0xffffffff
+#ifdef DBUS_HAVE_INT64
+#define _DBUS_INT64_MAX DBUS_INT64_CONSTANT (9223372036854775807)
+#define _DBUS_UINT64_MAX DBUS_UINT64_CONSTANT (0xffffffffffffffff)
+#endif
#define _DBUS_ONE_KILOBYTE 1024
#define _DBUS_ONE_MEGABYTE 1024 * _DBUS_ONE_KILOBYTE
#define _DBUS_ONE_HOUR_IN_MILLISECONDS (1000 * 60 * 60)
diff --git a/dbus/dbus-marshal.c b/dbus/dbus-marshal.c
index 02343174..e403bfdd 100644
--- a/dbus/dbus-marshal.c
+++ b/dbus/dbus-marshal.c
@@ -29,6 +29,30 @@
#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,
@@ -47,17 +71,38 @@ 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
@@ -70,12 +115,7 @@ dbus_uint32_t
_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);
}
/**
@@ -89,12 +129,78 @@ dbus_int32_t
_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
}
/**
@@ -109,12 +215,7 @@ _dbus_pack_uint32 (dbus_uint32_t value,
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);
}
/**
@@ -129,12 +230,75 @@ _dbus_pack_int32 (dbus_int32_t value,
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);
}
/**
@@ -153,14 +317,7 @@ _dbus_marshal_set_int32 (DBusString *str,
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);
}
/**
@@ -179,17 +336,55 @@ _dbus_marshal_set_uint32 (DBusString *str,
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
@@ -228,6 +423,38 @@ _dbus_marshal_set_string (DBusString *str,
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.
*
@@ -241,15 +468,9 @@ _dbus_marshal_double (DBusString *str,
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);
}
/**
@@ -265,13 +486,7 @@ _dbus_marshal_int32 (DBusString *str,
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);
}
/**
@@ -287,15 +502,49 @@ _dbus_marshal_uint32 (DBusString *str,
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
*
@@ -362,6 +611,96 @@ _dbus_marshal_byte_array (DBusString *str,
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
*
@@ -377,24 +716,9 @@ _dbus_marshal_int32_array (DBusString *str,
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);
}
/**
@@ -412,26 +736,55 @@ _dbus_marshal_uint32_array (DBusString *str,
const dbus_uint32_t *value,
int len)
{
- int i, old_string_len;
-
- old_string_len = _dbus_string_get_length (str);
+ return marshal_4_octets_array (str, byte_order,
+ value,
+ len);
+}
- if (!_dbus_marshal_uint32 (str, byte_order, len * sizeof (dbus_uint32_t)))
- goto error;
+#ifdef DBUS_HAVE_INT64
- 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
*
@@ -447,32 +800,9 @@ _dbus_marshal_double_array (DBusString *str,
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);
}
/**
@@ -518,6 +848,37 @@ _dbus_marshal_string_array (DBusString *str,
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.
@@ -530,26 +891,15 @@ _dbus_marshal_string_array (DBusString *str,
*/
double
_dbus_demarshal_double (const DBusString *str,
- int byte_order,
- int pos,
- int *new_pos)
+ 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));
+ DBusOctets8 r;
- retval = *(double *)buffer;
-
- if (byte_order != DBUS_COMPILER_BYTE_ORDER)
- swap_bytes ((unsigned char *)&retval, sizeof (double));
+ r = demarshal_8_octets (str, byte_order, pos, new_pos);
- if (new_pos)
- *new_pos = pos + sizeof (double);
-
- return retval;
+ return r.d;
}
/**
@@ -567,17 +917,7 @@ _dbus_demarshal_int32 (const DBusString *str,
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);
-
- 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));
+ return (dbus_int32_t) demarshal_4_octets (str, byte_order, pos, new_pos);
}
/**
@@ -595,20 +935,58 @@ _dbus_demarshal_uint32 (const DBusString *str,
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);
+ return demarshal_4_octets (str, byte_order, pos, new_pos);
+}
- 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));
+#ifdef DBUS_HAVE_INT64
+
+/**
+ * Demarshals a 64 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_int64_t
+_dbus_demarshal_int64 (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.s;
}
/**
+ * Demarshals a 64 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 integer.
+ */
+dbus_uint64_t
+_dbus_demarshal_uint64 (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.u;
+}
+
+#endif /* DBUS_HAVE_INT64 */
+
+/**
* Demarshals an UTF-8 string.
*
* @todo Should we check the string to make sure
@@ -718,29 +1096,20 @@ _dbus_demarshal_byte_array (const DBusString *str,
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)
{
@@ -752,47 +1121,40 @@ _dbus_demarshal_int32_array (const DBusString *str,
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)
{
@@ -804,17 +1166,25 @@ _dbus_demarshal_uint32_array (const DBusString *str,
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;
@@ -823,7 +1193,7 @@ _dbus_demarshal_uint32_array (const DBusString *str,
}
/**
- * Demarshals a double array.
+ * Demarshals a 32 bit signed integer array.
*
* @param str the string containing the data
* @param byte_order the byte order
@@ -834,44 +1204,111 @@ _dbus_demarshal_uint32_array (const DBusString *str,
* @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);
+ return demarshal_4_octets_array (str, byte_order, pos, new_pos,
+ array, array_len);
+}
- if (len == 0)
- {
- *array_len = 0;
- *array = NULL;
+#ifdef DBUS_HAVE_INT64
- if (new_pos)
- *new_pos = pos;
-
- return TRUE;
- }
-
- retval = dbus_new (double, len);
-
- 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);
}
/**
@@ -991,6 +1428,18 @@ _dbus_marshal_get_arg_end_pos (const DBusString *str,
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);
@@ -1263,9 +1712,10 @@ _dbus_marshal_validate_arg (const DBusString *str,
return FALSE;
}
- *end_pos = pos + 1;
- break;
+ *end_pos = pos + 1;
}
+ break;
+
case DBUS_TYPE_INT32:
case DBUS_TYPE_UINT32:
{
@@ -1282,6 +1732,22 @@ _dbus_marshal_validate_arg (const DBusString *str,
}
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);
@@ -1597,8 +2063,11 @@ _dbus_marshal_test (void)
{
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");
@@ -1636,6 +2105,30 @@ _dbus_marshal_test (void)
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))
@@ -1662,6 +2155,18 @@ _dbus_marshal_test (void)
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);
diff --git a/dbus/dbus-marshal.h b/dbus/dbus-marshal.h
index 53b9b7b3..1eff8995 100644
--- a/dbus/dbus-marshal.h
+++ b/dbus/dbus-marshal.h
@@ -27,6 +27,7 @@
#include <config.h>
#include <dbus/dbus-protocol.h>
#include <dbus/dbus-types.h>
+#include <dbus/dbus-arch-deps.h>
#include <dbus/dbus-string.h>
#ifndef PACKAGE
@@ -39,25 +40,63 @@
#define DBUS_COMPILER_BYTE_ORDER DBUS_LITTLE_ENDIAN
#endif
-#define DBUS_UINT32_SWAP_LE_BE_CONSTANT(val) ((dbus_uint32_t) ( \
- (((dbus_uint32_t) (val) & (dbus_uint32_t) 0x000000ffU) << 24) | \
- (((dbus_uint32_t) (val) & (dbus_uint32_t) 0x0000ff00U) << 8) | \
- (((dbus_uint32_t) (val) & (dbus_uint32_t) 0x00ff0000U) >> 8) | \
+#define DBUS_UINT32_SWAP_LE_BE_CONSTANT(val) ((dbus_uint32_t) ( \
+ (((dbus_uint32_t) (val) & (dbus_uint32_t) 0x000000ffU) << 24) | \
+ (((dbus_uint32_t) (val) & (dbus_uint32_t) 0x0000ff00U) << 8) | \
+ (((dbus_uint32_t) (val) & (dbus_uint32_t) 0x00ff0000U) >> 8) | \
(((dbus_uint32_t) (val) & (dbus_uint32_t) 0xff000000U) >> 24)))
+#ifdef DBUS_HAVE_INT64
+
+#define DBUS_UINT64_SWAP_LE_BE_CONSTANT(val) ((dbus_uint64_t) ( \
+ (((dbus_uint64_t) (val) & \
+ (dbus_uint64_t) DBUS_UINT64_CONSTANT (0x00000000000000ff)) << 56) | \
+ (((dbus_uint64_t) (val) & \
+ (dbus_uint64_t) DBUS_UINT64_CONSTANT (0x000000000000ff00)) << 40) | \
+ (((dbus_uint64_t) (val) & \
+ (dbus_uint64_t) DBUS_UINT64_CONSTANT (0x0000000000ff0000)) << 24) | \
+ (((dbus_uint64_t) (val) & \
+ (dbus_uint64_t) DBUS_UINT64_CONSTANT (0x00000000ff000000)) << 8) | \
+ (((dbus_uint64_t) (val) & \
+ (dbus_uint64_t) DBUS_UINT64_CONSTANT (0x000000ff00000000)) >> 8) | \
+ (((dbus_uint64_t) (val) & \
+ (dbus_uint64_t) DBUS_UINT64_CONSTANT (0x0000ff0000000000)) >> 24) | \
+ (((dbus_uint64_t) (val) & \
+ (dbus_uint64_t) DBUS_UINT64_CONSTANT (0x00ff000000000000)) >> 40) | \
+ (((dbus_uint64_t) (val) & \
+ (dbus_uint64_t) DBUS_UINT64_CONSTANT (0xff00000000000000)) >> 56)))
+#endif /* DBUS_HAVE_INT64 */
+
#define DBUS_UINT32_SWAP_LE_BE(val) (DBUS_UINT32_SWAP_LE_BE_CONSTANT (val))
#define DBUS_INT32_SWAP_LE_BE(val) ((dbus_int32_t)DBUS_UINT32_SWAP_LE_BE_CONSTANT (val))
+#ifdef DBUS_HAVE_INT64
+#define DBUS_UINT64_SWAP_LE_BE(val) (DBUS_UINT64_SWAP_LE_BE_CONSTANT (val))
+#define DBUS_INT64_SWAP_LE_BE(val) ((dbus_int64_t)DBUS_UINT64_SWAP_LE_BE_CONSTANT (val))
+#endif /* DBUS_HAVE_INT64 */
+
#ifdef WORDS_BIGENDIAN
#define DBUS_INT32_TO_BE(val) ((dbus_int32_t) (val))
#define DBUS_UINT32_TO_BE(val) ((dbus_uint32_t) (val))
#define DBUS_INT32_TO_LE(val) (DBUS_INT32_SWAP_LE_BE (val))
#define DBUS_UINT32_TO_LE(val) (DBUS_UINT32_SWAP_LE_BE (val))
+# ifdef DBUS_HAVE_INT64
+#define DBUS_INT64_TO_BE(val) ((dbus_int64_t) (val))
+#define DBUS_UINT64_TO_BE(val) ((dbus_uint64_t) (val))
+#define DBUS_INT64_TO_LE(val) (DBUS_INT64_SWAP_LE_BE (val))
+#define DBUS_UINT64_TO_LE(val) (DBUS_UINT64_SWAP_LE_BE (val))
+# endif /* DBUS_HAVE_INT64 */
#else
#define DBUS_INT32_TO_LE(val) ((dbus_int32_t) (val))
#define DBUS_UINT32_TO_LE(val) ((dbus_uint32_t) (val))
#define DBUS_INT32_TO_BE(val) ((dbus_int32_t) DBUS_UINT32_SWAP_LE_BE (val))
#define DBUS_UINT32_TO_BE(val) (DBUS_UINT32_SWAP_LE_BE (val))
+# ifdef DBUS_HAVE_INT64
+#define DBUS_INT64_TO_LE(val) ((dbus_int64_t) (val))
+#define DBUS_UINT64_TO_LE(val) ((dbus_uint64_t) (val))
+#define DBUS_INT64_TO_BE(val) ((dbus_int64_t) DBUS_UINT64_SWAP_LE_BE (val))
+#define DBUS_UINT64_TO_BE(val) (DBUS_UINT64_SWAP_LE_BE (val))
+# endif /* DBUS_HAVE_INT64 */
#endif
/* The transformation is symmetric, so the FROM just maps to the TO. */
@@ -65,6 +104,12 @@
#define DBUS_UINT32_FROM_LE(val) (DBUS_UINT32_TO_LE (val))
#define DBUS_INT32_FROM_BE(val) (DBUS_INT32_TO_BE (val))
#define DBUS_UINT32_FROM_BE(val) (DBUS_UINT32_TO_BE (val))
+#ifdef DBUS_HAVE_INT64
+#define DBUS_INT64_FROM_LE(val) (DBUS_INT64_TO_LE (val))
+#define DBUS_UINT64_FROM_LE(val) (DBUS_UINT64_TO_LE (val))
+#define DBUS_INT64_FROM_BE(val) (DBUS_INT64_TO_BE (val))
+#define DBUS_UINT64_FROM_BE(val) (DBUS_UINT64_TO_BE (val))
+#endif /* DBUS_HAVE_INT64 */
void _dbus_pack_int32 (dbus_int32_t value,
int byte_order,
@@ -76,6 +121,18 @@ void _dbus_pack_uint32 (dbus_uint32_t value,
unsigned char *data);
dbus_uint32_t _dbus_unpack_uint32 (int byte_order,
const unsigned char *data);
+#ifdef DBUS_HAVE_INT64
+void _dbus_pack_int64 (dbus_int64_t value,
+ int byte_order,
+ unsigned char *data);
+dbus_int64_t _dbus_unpack_int64 (int byte_order,
+ const unsigned char *data);
+void _dbus_pack_uint64 (dbus_uint64_t value,
+ int byte_order,
+ unsigned char *data);
+dbus_uint64_t _dbus_unpack_uint64 (int byte_order,
+ const unsigned char *data);
+#endif /* DBUS_HAVE_INT64 */
void _dbus_marshal_set_int32 (DBusString *str,
int byte_order,
@@ -85,6 +142,16 @@ void _dbus_marshal_set_uint32 (DBusString *str,
int byte_order,
int offset,
dbus_uint32_t value);
+#ifdef DBUS_HAVE_INT64
+void _dbus_marshal_set_int64 (DBusString *str,
+ int byte_order,
+ int offset,
+ dbus_int64_t value);
+void _dbus_marshal_set_uint64 (DBusString *str,
+ int byte_order,
+ int offset,
+ dbus_uint64_t value);
+#endif /* DBUS_HAVE_INT64 */
dbus_bool_t _dbus_marshal_set_string (DBusString *str,
int byte_order,
int offset,
@@ -97,6 +164,14 @@ dbus_bool_t _dbus_marshal_int32 (DBusString *str,
dbus_bool_t _dbus_marshal_uint32 (DBusString *str,
int byte_order,
dbus_uint32_t value);
+#ifdef DBUS_HAVE_INT64
+dbus_bool_t _dbus_marshal_int64 (DBusString *str,
+ int byte_order,
+ dbus_int64_t value);
+dbus_bool_t _dbus_marshal_uint64 (DBusString *str,
+ int byte_order,
+ dbus_uint64_t value);
+#endif /* DBUS_HAVE_INT64 */
dbus_bool_t _dbus_marshal_double (DBusString *str,
int byte_order,
double value);
@@ -115,6 +190,16 @@ dbus_bool_t _dbus_marshal_uint32_array (DBusString *str,
int byte_order,
const dbus_uint32_t *value,
int len);
+#ifdef DBUS_HAVE_INT64
+dbus_bool_t _dbus_marshal_int64_array (DBusString *str,
+ int byte_order,
+ const dbus_int64_t *value,
+ int len);
+dbus_bool_t _dbus_marshal_uint64_array (DBusString *str,
+ int byte_order,
+ const dbus_uint64_t *value,
+ int len);
+#endif /* DBUS_HAVE_INT64 */
dbus_bool_t _dbus_marshal_double_array (DBusString *str,
int byte_order,
const double *value,
@@ -135,6 +220,16 @@ dbus_uint32_t _dbus_demarshal_uint32 (const DBusString *str,
int byte_order,
int pos,
int *new_pos);
+#ifdef DBUS_HAVE_INT64
+dbus_int64_t _dbus_demarshal_int64 (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos);
+dbus_uint64_t _dbus_demarshal_uint64 (const DBusString *str,
+ int byte_order,
+ int pos,
+ int *new_pos);
+#endif /* DBUS_HAVE_INT64 */
char * _dbus_demarshal_string (const DBusString *str,
int byte_order,
int pos,
@@ -157,6 +252,20 @@ dbus_bool_t _dbus_demarshal_uint32_array (const DBusString *str,
int *new_pos,
dbus_uint32_t **array,
int *array_len);
+#ifdef DBUS_HAVE_INT64
+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);
+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);
+#endif /* DBUS_HAVE_INT64 */
dbus_bool_t _dbus_demarshal_double_array (const DBusString *str,
int byte_order,
int pos,
diff --git a/dbus/dbus-message-builder.c b/dbus/dbus-message-builder.c
index 93d65e62..135e4bb0 100644
--- a/dbus/dbus-message-builder.c
+++ b/dbus/dbus-message-builder.c
@@ -295,6 +295,8 @@ append_saved_length (DBusString *dest,
* @code
* INT32 <N> marshals an INT32
* UINT32 <N> marshals a UINT32
+ * INT64 <N> marshals an INT64
+ * UINT64 <N> marshals a UINT64
* DOUBLE <N> marshals a double
* STRING 'Foo' marshals a string
* BYTE_ARRAY { 'a', 3, 4, 5, 6} marshals a BYTE array
diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c
index af949fb4..fe07c865 100644
--- a/dbus/dbus-message.c
+++ b/dbus/dbus-message.c
@@ -1195,15 +1195,18 @@ dbus_message_get_service (DBusMessage *message)
}
/**
- * 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
@@ -1227,10 +1230,11 @@ dbus_message_append_args (DBusMessage *message,
}
/**
- * 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
@@ -1272,6 +1276,16 @@ dbus_message_append_args_valist (DBusMessage *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;
@@ -1321,6 +1335,16 @@ dbus_message_append_args_valist (DBusMessage *message,
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;
@@ -1447,6 +1471,9 @@ dbus_message_iter_get_args (DBusMessageIter *iter,
/**
* 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
@@ -1534,7 +1561,27 @@ dbus_message_iter_get_args_valist (DBusMessageIter *iter,
*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;
@@ -1628,6 +1675,22 @@ dbus_message_iter_get_args_valist (DBusMessageIter *iter,
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))
{
@@ -2077,7 +2140,7 @@ dbus_message_iter_get_boolean (DBusMessageIter *iter)
/**
* 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
@@ -2102,7 +2165,7 @@ dbus_message_iter_get_int32 (DBusMessageIter *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
@@ -2124,6 +2187,64 @@ dbus_message_iter_get_uint32 (DBusMessageIter *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
@@ -2386,6 +2507,83 @@ dbus_message_iter_get_uint32_array (DBusMessageIter *iter,
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
@@ -2731,6 +2929,72 @@ dbus_message_iter_append_uint32 (DBusMessageIter *iter,
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.
*
@@ -3145,6 +3409,75 @@ dbus_message_iter_append_uint32_array (DBusMessageIter *iter,
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.
*
@@ -3648,7 +3981,8 @@ decode_string_field (const DBusString *data,
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;
}
@@ -4414,6 +4748,16 @@ check_message_handling_type (DBusMessageIter *iter,
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;
@@ -5029,12 +5373,18 @@ verify_test_message (DBusMessage *message)
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,
@@ -5048,6 +5398,11 @@ verify_test_message (DBusMessage *message)
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!");
@@ -5134,6 +5489,9 @@ _dbus_message_test (const char *test_data_dir)
_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,
diff --git a/dbus/dbus-message.h b/dbus/dbus-message.h
index c692f919..f7ca1c4d 100644
--- a/dbus/dbus-message.h
+++ b/dbus/dbus-message.h
@@ -29,6 +29,7 @@
#include <dbus/dbus-macros.h>
#include <dbus/dbus-types.h>
+#include <dbus/dbus-arch-deps.h>
#include <stdarg.h>
DBUS_BEGIN_DECLS;
@@ -119,6 +120,10 @@ unsigned char dbus_message_iter_get_byte (DBusMessageIter *iter);
dbus_bool_t dbus_message_iter_get_boolean (DBusMessageIter *iter);
dbus_int32_t dbus_message_iter_get_int32 (DBusMessageIter *iter);
dbus_uint32_t dbus_message_iter_get_uint32 (DBusMessageIter *iter);
+#ifdef DBUS_HAVE_INT64
+dbus_int64_t dbus_message_iter_get_int64 (DBusMessageIter *iter);
+dbus_uint64_t dbus_message_iter_get_uint64 (DBusMessageIter *iter);
+#endif /* DBUS_HAVE_INT64 */
double dbus_message_iter_get_double (DBusMessageIter *iter);
char * dbus_message_iter_get_string (DBusMessageIter *iter);
char * dbus_message_iter_get_dict_key (DBusMessageIter *iter);
@@ -144,6 +149,14 @@ dbus_bool_t dbus_message_iter_get_int32_array (DBusMessageIter *iter,
dbus_bool_t dbus_message_iter_get_uint32_array (DBusMessageIter *iter,
dbus_uint32_t **value,
int *len);
+#ifdef DBUS_HAVE_INT64
+dbus_bool_t dbus_message_iter_get_int64_array (DBusMessageIter *iter,
+ dbus_int64_t **value,
+ int *len);
+dbus_bool_t dbus_message_iter_get_uint64_array (DBusMessageIter *iter,
+ dbus_uint64_t **value,
+ int *len);
+#endif /* DBUS_HAVE_INT64 */
dbus_bool_t dbus_message_iter_get_double_array (DBusMessageIter *iter,
double **value,
int *len);
@@ -163,6 +176,12 @@ dbus_bool_t dbus_message_iter_append_int32 (DBusMessageIter *iter,
dbus_int32_t value);
dbus_bool_t dbus_message_iter_append_uint32 (DBusMessageIter *iter,
dbus_uint32_t value);
+#ifdef DBUS_HAVE_INT64
+dbus_bool_t dbus_message_iter_append_int64 (DBusMessageIter *iter,
+ dbus_int64_t value);
+dbus_bool_t dbus_message_iter_append_uint64 (DBusMessageIter *iter,
+ dbus_uint64_t value);
+#endif /* DBUS_HAVE_INT64 */
dbus_bool_t dbus_message_iter_append_double (DBusMessageIter *iter,
double value);
dbus_bool_t dbus_message_iter_append_string (DBusMessageIter *iter,
@@ -189,6 +208,14 @@ dbus_bool_t dbus_message_iter_append_int32_array (DBusMessageIter *iter,
dbus_bool_t dbus_message_iter_append_uint32_array (DBusMessageIter *iter,
const dbus_uint32_t *value,
int len);
+#ifdef DBUS_HAVE_INT64
+dbus_bool_t dbus_message_iter_append_int64_array (DBusMessageIter *iter,
+ const dbus_int64_t *value,
+ int len);
+dbus_bool_t dbus_message_iter_append_uint64_array (DBusMessageIter *iter,
+ const dbus_uint64_t *value,
+ int len);
+#endif /* DBUS_HAVE_INT64 */
dbus_bool_t dbus_message_iter_append_double_array (DBusMessageIter *iter,
const double *value,
int len);
diff --git a/dbus/dbus-protocol.h b/dbus/dbus-protocol.h
index 314a9934..fbdcb6dd 100644
--- a/dbus/dbus-protocol.h
+++ b/dbus/dbus-protocol.h
@@ -46,11 +46,13 @@ extern "C" {
#define DBUS_TYPE_BOOLEAN 3
#define DBUS_TYPE_INT32 4
#define DBUS_TYPE_UINT32 5
-#define DBUS_TYPE_DOUBLE 6
-#define DBUS_TYPE_STRING 7
-#define DBUS_TYPE_NAMED 8
-#define DBUS_TYPE_ARRAY 9
-#define DBUS_TYPE_DICT 10
+#define DBUS_TYPE_INT64 6
+#define DBUS_TYPE_UINT64 7
+#define DBUS_TYPE_DOUBLE 8
+#define DBUS_TYPE_STRING 9
+#define DBUS_TYPE_NAMED 10
+#define DBUS_TYPE_ARRAY 11
+#define DBUS_TYPE_DICT 12
#define DBUS_TYPE_LAST DBUS_TYPE_DICT
diff --git a/dbus/dbus.h b/dbus/dbus.h
index 025ccbb2..4285b395 100644
--- a/dbus/dbus.h
+++ b/dbus/dbus.h
@@ -26,6 +26,7 @@
#define DBUS_INSIDE_DBUS_H 1
+#include <dbus/dbus-arch-deps.h>
#include <dbus/dbus-address.h>
#include <dbus/dbus-bus.h>
#include <dbus/dbus-connection.h>
diff --git a/doc/dbus-specification.sgml b/doc/dbus-specification.sgml
index ad3b9adc..eda6c00e 100644
--- a/doc/dbus-specification.sgml
+++ b/doc/dbus-specification.sgml
@@ -327,25 +327,33 @@
<entry>UINT32</entry>
<entry>5</entry>
<entry>32-bit unsigned integer</entry>
+ </row><row>
+ <entry>INT64</entry>
+ <entry>6</entry>
+ <entry>64-bit signed integer</entry>
+ </row><row>
+ <entry>UINT64</entry>
+ <entry>7</entry>
+ <entry>64-bit unsigned integer</entry>
</row><row>
<entry>DOUBLE</entry>
- <entry>6</entry>
+ <entry>8</entry>
<entry>IEEE 754 double</entry>
</row><row>
<entry>STRING</entry>
- <entry>7</entry>
+ <entry>9</entry>
<entry>UTF-8 string (<emphasis>must</emphasis> be valid UTF-8). Must be zero terminated. </entry>
</row><row>
<entry>NAMED</entry>
- <entry>8</entry>
+ <entry>10</entry>
<entry>A named byte array, used for custom types</entry>
</row><row>
<entry>ARRAY</entry>
- <entry>9</entry>
+ <entry>11</entry>
<entry>Array</entry>
</row><row>
<entry>DICT</entry>
- <entry>10</entry>
+ <entry>12</entry>
<entry>A dictionary of key/value pairs</entry>
</row>
</tbody>
@@ -383,6 +391,12 @@
<entry>UINT32</entry>
<entry>32-bit unsigned integer in the message's byte order, aligned to 4-byte boundary.</entry>
</row><row>
+ <entry>INT64</entry>
+ <entry>64-bit signed integer in the message's byte order, aligned to 8-byte boundary.</entry>
+ </row><row>
+ <entry>UINT64</entry>
+ <entry>64-bit unsigned integer in the message's byte order, aligned to 8-byte boundary.</entry>
+ </row><row>
<entry>DOUBLE</entry>
<entry>64-bit IEEE 754 double in the message's byte order, aligned to 8-byte boundary.</entry>
</row><row>
diff --git a/test/decode-gcov.c b/test/decode-gcov.c
index f7104bf3..1ebba306 100644
--- a/test/decode-gcov.c
+++ b/test/decode-gcov.c
@@ -68,8 +68,6 @@ fetch_long (long *dest,
return 0;
}
-typedef DBUS_INT64_TYPE dbus_int64_t;
-
static int
fetch_long64 (dbus_int64_t *dest,
const char *source,
generated by cgit (git 2.34.1) at 2024-10-31 23:01:54 +0000