From b29d0c534a631b211f1f94168e7672c604c8f815 Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Wed, 23 Apr 2003 03:33:52 +0000 Subject: 2003-04-22 Havoc Pennington * 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 --- ChangeLog | 13 + configure.in | 32 +- dbus-1.0.pc.in | 2 +- dbus/Makefile.am | 7 + dbus/dbus-arch-deps.h.in | 51 +++ dbus/dbus-internals.h | 11 +- dbus/dbus-marshal.c | 1033 ++++++++++++++++++++++++++++++++----------- dbus/dbus-marshal.h | 117 ++++- dbus/dbus-message-builder.c | 2 + dbus/dbus-message.c | 382 +++++++++++++++- dbus/dbus-message.h | 27 ++ dbus/dbus-protocol.h | 12 +- dbus/dbus.h | 1 + doc/dbus-specification.sgml | 24 +- test/decode-gcov.c | 2 - 15 files changed, 1417 insertions(+), 299 deletions(-) create mode 100644 dbus/dbus-arch-deps.h.in diff --git a/ChangeLog b/ChangeLog index 7818e3f9..5d86d0ff 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,16 @@ +2003-04-22 Havoc Pennington + + * 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 * test/data/valid-messages/opposite-endian.message: fix test 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 can be included directly, this file may disappear or change contents." +#endif + +#ifndef DBUS_ARCH_DEPS_H +#define DBUS_ARCH_DEPS_H + +#include +#include + +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 +/** + * @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); } /** @@ -88,13 +128,79 @@ _dbus_unpack_uint32 (int byte_order, 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,16 +336,54 @@ _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 @@ -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; + 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 * @@ -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,42 +848,100 @@ _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. + * + * @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 @@ -561,27 +949,21 @@ _dbus_demarshal_double (const DBusString *str, * @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 @@ -589,25 +971,21 @@ _dbus_demarshal_int32 (const DBusString *str, * @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. * @@ -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); - - 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); } /** @@ -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 #include #include +#include #include #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 marshals an INT32 * UINT32 marshals a UINT32 + * INT64 marshals an INT64 + * UINT64 marshals a UINT64 * DOUBLE 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 #include +#include #include 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 #include #include #include 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 @@ UINT32 5 32-bit unsigned integer + + INT64 + 6 + 64-bit signed integer + + UINT64 + 7 + 64-bit unsigned integer DOUBLE - 6 + 8 IEEE 754 double STRING - 7 + 9 UTF-8 string (must be valid UTF-8). Must be zero terminated. NAMED - 8 + 10 A named byte array, used for custom types ARRAY - 9 + 11 Array DICT - 10 + 12 A dictionary of key/value pairs @@ -382,6 +390,12 @@ UINT32 32-bit unsigned integer in the message's byte order, aligned to 4-byte boundary. + + INT64 + 64-bit signed integer in the message's byte order, aligned to 8-byte boundary. + + UINT64 + 64-bit unsigned integer in the message's byte order, aligned to 8-byte boundary. DOUBLE 64-bit IEEE 754 double in the message's byte order, aligned to 8-byte boundary. 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, -- cgit