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

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,