2005-01-27 Havoc Pennington <hp@redhat.com>

	* dbus/dbus-arch-deps.h.in: add 16/32-bit types

	* configure.in: find the right type for 16 and 32 bit ints as well
	as 64

	* dbus/dbus-protocol.h (DBUS_TYPE_INT16, DBUS_TYPE_UINT16): add
	the 16-bit types so people don't have to stuff them in 32-bit or
	byte arrays.

25 files changed, 631 insertions, 61 deletions

diff --git a/ChangeLog b/ChangeLog
index c1d24655..137ebe26 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,16 @@
 2005-01-27  Havoc Pennington  <hp@redhat.com>
 
+	* dbus/dbus-arch-deps.h.in: add 16/32-bit types
+
+	* configure.in: find the right type for 16 and 32 bit ints as well
+	as 64
+
+	* dbus/dbus-protocol.h (DBUS_TYPE_INT16, DBUS_TYPE_UINT16): add
+	the 16-bit types so people don't have to stuff them in 32-bit or
+	byte arrays.
+
+2005-01-27  Havoc Pennington  <hp@redhat.com>
+
         * dbus/dbus-message.c: byteswap the message if you init an
 	iterator to read/write from it
 	
diff --git a/configure.in b/configure.in
index 95ab6d1e..71efb27f 100644
--- a/configure.in
+++ b/configure.in
@@ -369,6 +369,53 @@ AC_SUBST(DBUS_INT64_CONSTANT)
 AC_SUBST(DBUS_UINT64_CONSTANT)
 AC_SUBST(DBUS_HAVE_INT64)
 
+### see what 32-bit int is called
+AC_MSG_CHECKING([32-bit integer type])
+
+case 4 in
+$ac_cv_sizeof_short)
+  dbusint32=int
+  ;;
+$ac_cv_sizeof_int)
+  dbusint32=int
+  ;;
+$ac_cv_sizeof_long)
+  dbusint32=long
+  ;;
+esac
+
+if test -z "$dbusint32" ; then
+        DBUS_INT32_TYPE="no_int32_type_detected"
+        AC_MSG_ERROR([No 32-bit integer type found])
+else
+        DBUS_INT32_TYPE="$dbusint32"
+        AC_MSG_RESULT($DBUS_INT32_TYPE)
+fi
+
+AC_SUBST(DBUS_INT32_TYPE)
+
+### see what 16-bit int is called
+AC_MSG_CHECKING([16-bit integer type])
+
+case 2 in
+$ac_cv_sizeof_short)
+  dbusint16=short
+  ;;
+$ac_cv_sizeof_int)
+  dbusint16=int
+  ;;
+esac
+
+if test -z "$dbusint16" ; then
+        DBUS_INT16_TYPE="no_int16_type_detected"
+        AC_MSG_ERROR([No 16-bit integer type found])
+else
+        DBUS_INT16_TYPE="$dbusint16"
+        AC_MSG_RESULT($DBUS_INT16_TYPE)
+fi
+
+AC_SUBST(DBUS_INT16_TYPE)
+
 ## byte order
 AC_C_BIGENDIAN
 
@@ -1194,6 +1241,8 @@ echo "
 	cppflags:		  ${CPPFLAGS}
 	cxxflags:		  ${CXXFLAGS}
 	64-bit int:		  ${DBUS_INT64_TYPE}
+	32-bit int:		  ${DBUS_INT32_TYPE}
+	16-bit int:		  ${DBUS_INT16_TYPE}
         Doxygen:                  ${DOXYGEN}
         xmlto:                    ${XMLTO}"
 
diff --git a/dbus/dbus-arch-deps.h.in b/dbus/dbus-arch-deps.h.in
index 9d0d597f..b5891e61 100644
--- a/dbus/dbus-arch-deps.h.in
+++ b/dbus/dbus-arch-deps.h.in
@@ -27,7 +27,6 @@
 #ifndef DBUS_ARCH_DEPS_H
 #define DBUS_ARCH_DEPS_H
 
-#include <dbus/dbus-types.h>
 #include <dbus/dbus-macros.h>
 
 DBUS_BEGIN_DECLS;
@@ -46,6 +45,12 @@ typedef unsigned @DBUS_INT64_TYPE@ dbus_uint64_t;
 #undef DBUS_UINT64_CONSTANT
 #endif
 
+typedef @DBUS_INT32_TYPE@ dbus_int32_t;
+typedef unsigned @DBUS_INT32_TYPE@ dbus_uint32_t;
+
+typedef @DBUS_INT16_TYPE@ dbus_int16_t;
+typedef unsigned @DBUS_INT16_TYPE@ dbus_uint16_t;
+
 DBUS_END_DECLS;
 
 #endif /* DBUS_ARCH_DEPS_H */
diff --git a/dbus/dbus-bus.c b/dbus/dbus-bus.c
index bc6a3bf5..92e9f963 100644
--- a/dbus/dbus-bus.c
+++ b/dbus/dbus-bus.c
@@ -26,6 +26,7 @@
 #include "dbus-protocol.h"
 #include "dbus-internals.h"
 #include "dbus-message.h"
+#include "dbus-marshal-validate.h"
 #include <string.h>
 
 /**
diff --git a/dbus/dbus-internals.c b/dbus/dbus-internals.c
index 8d0a968b..1e1753da 100644
--- a/dbus/dbus-internals.c
+++ b/dbus/dbus-internals.c
@@ -98,6 +98,38 @@
  * @param object the object to be zeroed.
  */
 /**
+ * @def _DBUS_INT16_MIN
+ *
+ * Minimum value of type "int16"
+ */
+/**
+ * @def _DBUS_INT16_MAX
+ *
+ * Maximum value of type "int16"
+ */
+/**
+ * @def _DBUS_UINT16_MAX
+ *
+ * Maximum value of type "uint16"
+ */
+
+/**
+ * @def _DBUS_INT32_MIN
+ *
+ * Minimum value of type "int32"
+ */
+/**
+ * @def _DBUS_INT32_MAX
+ *
+ * Maximum value of type "int32"
+ */
+/**
+ * @def _DBUS_UINT32_MAX
+ *
+ * Maximum value of type "uint32"
+ */
+
+/**
  * @def _DBUS_INT_MIN
  *
  * Minimum value of type "int"
@@ -107,6 +139,11 @@
  *
  * Maximum value of type "int"
  */
+/**
+ * @def _DBUS_UINT_MAX
+ *
+ * Maximum value of type "uint"
+ */
 
 /**
  * @typedef DBusForeachFunction
diff --git a/dbus/dbus-internals.h b/dbus/dbus-internals.h
index 2ffd2341..3f0a34fe 100644
--- a/dbus/dbus-internals.h
+++ b/dbus/dbus-internals.h
@@ -183,11 +183,18 @@ 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_INT16_MIN	 ((dbus_int16_t) 0x8000)
+#define _DBUS_INT16_MAX	 ((dbus_int16_t) 0x7fff)
+#define _DBUS_UINT16_MAX ((dbus_uint16_t)0xffff)
+#define _DBUS_INT32_MIN	 ((dbus_int32_t) 0x80000000)
+#define _DBUS_INT32_MAX	 ((dbus_int32_t) 0x7fffffff)
+#define _DBUS_UINT32_MAX ((dbus_uint32_t)0xffffffff)
+/* using 32-bit here is sort of bogus */
+#define _DBUS_INT_MIN	 _DBUS_INT32_MIN
+#define _DBUS_INT_MAX	 _DBUS_INT32_MAX
+#define _DBUS_UINT_MAX	 _DBUS_UINT32_MAX
 #ifdef DBUS_HAVE_INT64
-#define _DBUS_INT64_MAX	 DBUS_INT64_CONSTANT (9223372036854775807)
+#define _DBUS_INT64_MAX	 DBUS_INT64_CONSTANT  (0x7fffffffffffffff)
 #define _DBUS_UINT64_MAX DBUS_UINT64_CONSTANT (0xffffffffffffffff)
 #endif
 #define _DBUS_ONE_KILOBYTE 1024
diff --git a/dbus/dbus-keyring.c b/dbus/dbus-keyring.c
index 615a145d..8fbfd685 100644
--- a/dbus/dbus-keyring.c
+++ b/dbus/dbus-keyring.c
@@ -489,7 +489,7 @@ _dbus_keyring_reload (DBusKeyring *keyring,
           continue;
         }
 
-      if (val > _DBUS_INT_MAX || val < 0)
+      if (val > _DBUS_INT32_MAX || val < 0)
         {
           _dbus_verbose ("invalid secret key ID at start of line\n");
           continue;
diff --git a/dbus/dbus-marshal-basic.c b/dbus/dbus-marshal-basic.c
index cd5d4e45..e4f6720c 100644
--- a/dbus/dbus-marshal-basic.c
+++ b/dbus/dbus-marshal-basic.c
@@ -43,6 +43,19 @@
  */
 
 static void
+pack_2_octets (dbus_uint16_t   value,
+               int             byte_order,
+               unsigned char  *data)
+{
+  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 2) == data);
+
+  if ((byte_order) == DBUS_LITTLE_ENDIAN)
+    *((dbus_uint16_t*)(data)) = DBUS_UINT16_TO_LE (value);
+  else
+    *((dbus_uint16_t*)(data)) = DBUS_UINT16_TO_BE (value);
+}
+
+static void
 pack_4_octets (dbus_uint32_t   value,
                int             byte_order,
                unsigned char  *data)
@@ -147,6 +160,27 @@ unpack_8_octets (int                  byte_order,
 }
 #endif
 
+#ifndef _dbus_unpack_uint16
+/**
+ * Unpacks a 16 bit unsigned integer from a data pointer
+ *
+ * @param byte_order The byte order to use
+ * @param data the data pointer
+ * @returns the integer
+ */
+dbus_uint16_t
+_dbus_unpack_uint16 (int                  byte_order,
+                     const unsigned char *data)
+{
+  _dbus_assert (_DBUS_ALIGN_ADDRESS (data, 4) == data);
+
+  if (byte_order == DBUS_LITTLE_ENDIAN)
+    return DBUS_UINT16_FROM_LE (*(dbus_uint16_t*)data);
+  else
+    return DBUS_UINT16_FROM_BE (*(dbus_uint16_t*)data);
+}
+#endif /* _dbus_unpack_uint16 */
+
 #ifndef _dbus_unpack_uint32
 /**
  * Unpacks a 32 bit unsigned integer from a data pointer
@@ -169,6 +203,22 @@ _dbus_unpack_uint32 (int                  byte_order,
 #endif /* _dbus_unpack_uint32 */
 
 static void
+set_2_octets (DBusString          *str,
+              int                  offset,
+              dbus_uint16_t        value,
+              int                  byte_order)
+{
+  char *data;
+
+  _dbus_assert (byte_order == DBUS_LITTLE_ENDIAN ||
+                byte_order == DBUS_BIG_ENDIAN);
+
+  data = _dbus_string_get_data_len (str, offset, 2);
+
+  pack_2_octets (value, byte_order, data);
+}
+
+static void
 set_4_octets (DBusString          *str,
               int                  offset,
               dbus_uint32_t        value,
@@ -181,7 +231,7 @@ set_4_octets (DBusString          *str,
 
   data = _dbus_string_get_data_len (str, offset, 4);
 
-  _dbus_pack_uint32 (value, byte_order, data);
+  pack_4_octets (value, byte_order, data);
 }
 
 static void
@@ -350,6 +400,16 @@ _dbus_marshal_set_basic (DBusString       *str,
         *new_end_pos = pos + 1;
       return TRUE;
       break;
+    case DBUS_TYPE_INT16:
+    case DBUS_TYPE_UINT16:
+      pos = _DBUS_ALIGN_VALUE (pos, 2);
+      set_2_octets (str, pos, vp->u16, byte_order);
+      if (old_end_pos)
+        *old_end_pos = pos + 2;
+      if (new_end_pos)
+        *new_end_pos = pos + 2;
+      return TRUE;
+      break;
     case DBUS_TYPE_BOOLEAN:
     case DBUS_TYPE_INT32:
     case DBUS_TYPE_UINT32:
@@ -460,6 +520,14 @@ _dbus_marshal_read_basic (const DBusString      *str,
       vp->byt = _dbus_string_get_byte (str, pos);
       (pos)++;
       break;
+    case DBUS_TYPE_INT16:
+    case DBUS_TYPE_UINT16:
+      pos = _DBUS_ALIGN_VALUE (pos, 2);
+      vp->u16 = *(dbus_uint16_t *)(str_data + pos);
+      if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+	vp->u16 = DBUS_UINT16_SWAP_LE_BE (vp->u16);
+      pos += 2;
+      break;
     case DBUS_TYPE_INT32:
     case DBUS_TYPE_UINT32:
     case DBUS_TYPE_BOOLEAN:
@@ -571,6 +639,35 @@ _dbus_marshal_read_fixed_multi  (const DBusString *str,
 }
 
 static dbus_bool_t
+marshal_2_octets (DBusString   *str,
+                  int           insert_at,
+                  dbus_uint16_t value,
+                  int           byte_order,
+                  int          *pos_after)
+{
+  dbus_bool_t retval;
+  int orig_len;
+
+  _dbus_assert (sizeof (value) == 2);
+
+  if (byte_order != DBUS_COMPILER_BYTE_ORDER)
+    value = DBUS_UINT16_SWAP_LE_BE (value);
+
+  orig_len = _dbus_string_get_length (str);
+
+  retval = _dbus_string_insert_2_aligned (str, insert_at,
+                                          (const unsigned char *)&value);
+
+  if (pos_after)
+    {
+      *pos_after = insert_at + (_dbus_string_get_length (str) - orig_len);
+      _dbus_assert (*pos_after <= _dbus_string_get_length (str));
+    }
+
+  return retval;
+}
+
+static dbus_bool_t
 marshal_4_octets (DBusString   *str,
                   int           insert_at,
                   dbus_uint32_t value,
@@ -762,6 +859,11 @@ _dbus_marshal_write_basic (DBusString *str,
         *pos_after = insert_at + 1;
       return TRUE;
       break;
+    case DBUS_TYPE_INT16:
+    case DBUS_TYPE_UINT16:
+      return marshal_2_octets (str, insert_at, vp->u16,
+                               byte_order, pos_after);
+      break;
     case DBUS_TYPE_BOOLEAN:
       return marshal_4_octets (str, insert_at, vp->u32 != FALSE,
                                byte_order, pos_after);
@@ -855,16 +957,24 @@ _dbus_swap_array (unsigned char *data,
           d += 8;
         }
     }
-  else
+  else if (alignment == 4)
     {
-      _dbus_assert (alignment == 4);
-      
       while (d != end)
         {
           *((dbus_uint32_t*)d) = DBUS_UINT32_SWAP_LE_BE (*((dbus_uint32_t*)d));
           d += 4;
         }
     }
+  else
+    {
+      _dbus_assert (alignment == 2);
+      
+      while (d != end)
+        {
+          *((dbus_uint16_t*)d) = DBUS_UINT16_SWAP_LE_BE (*((dbus_uint16_t*)d));
+          d += 2;
+        }
+    }
 }
 
 static void
@@ -979,6 +1089,9 @@ _dbus_marshal_write_fixed_multi (DBusString *str,
     case DBUS_TYPE_BYTE:
       return marshal_1_octets_array (str, insert_at, vp, n_elements, byte_order, pos_after);
       break;
+    case DBUS_TYPE_INT16:
+    case DBUS_TYPE_UINT16:
+      return marshal_fixed_multi (str, insert_at, vp, n_elements, byte_order, 2, pos_after);
       /* FIXME: we canonicalize to 0 or 1 for the single boolean case
        * should we here too ? */
     case DBUS_TYPE_BOOLEAN:
@@ -1024,6 +1137,11 @@ _dbus_marshal_skip_basic (const DBusString      *str,
     case DBUS_TYPE_BYTE:
       (*pos)++;
       break;
+    case DBUS_TYPE_INT16:
+    case DBUS_TYPE_UINT16:
+      *pos = _DBUS_ALIGN_VALUE (*pos, 2);
+      *pos += 2;
+      break;
     case DBUS_TYPE_BOOLEAN:
     case DBUS_TYPE_INT32:
     case DBUS_TYPE_UINT32:
@@ -1109,6 +1227,9 @@ _dbus_type_get_alignment (int typecode)
     case DBUS_TYPE_VARIANT:
     case DBUS_TYPE_SIGNATURE:
       return 1;
+    case DBUS_TYPE_INT16:
+    case DBUS_TYPE_UINT16:
+      return 2;
     case DBUS_TYPE_BOOLEAN:
     case DBUS_TYPE_INT32:
     case DBUS_TYPE_UINT32:
@@ -1150,6 +1271,8 @@ _dbus_type_is_valid (int typecode)
     {
     case DBUS_TYPE_BYTE:
     case DBUS_TYPE_BOOLEAN:
+    case DBUS_TYPE_INT16:
+    case DBUS_TYPE_UINT16:
     case DBUS_TYPE_INT32:
     case DBUS_TYPE_UINT32:
     case DBUS_TYPE_INT64:
@@ -1232,6 +1355,8 @@ _dbus_type_is_fixed (int typecode)
     {
     case DBUS_TYPE_BYTE:
     case DBUS_TYPE_BOOLEAN:
+    case DBUS_TYPE_INT16:
+    case DBUS_TYPE_UINT16:
     case DBUS_TYPE_INT32:
     case DBUS_TYPE_UINT32:
     case DBUS_TYPE_INT64:
@@ -1260,6 +1385,10 @@ _dbus_type_to_string (int typecode)
       return "boolean";
     case DBUS_TYPE_BYTE:
       return "byte";
+    case DBUS_TYPE_INT16:
+      return "int16";
+    case DBUS_TYPE_UINT16:
+      return "uint16";
     case DBUS_TYPE_INT32:
       return "int32";
     case DBUS_TYPE_UINT32:
@@ -1558,6 +1687,7 @@ _dbus_marshal_test (void)
   DBusString str;
   int pos, dump_pos;
   unsigned char array1[5] = { 3, 4, 0, 1, 9 };
+  dbus_int16_t array2[3] = { 124, 457, 780 };
   dbus_int32_t array4[3] = { 123, 456, 789 };
 #ifdef DBUS_HAVE_INT64
   dbus_int64_t array8[3] = { DBUS_INT64_CONSTANT (0x123ffffffff),
@@ -1566,11 +1696,16 @@ _dbus_marshal_test (void)
   dbus_int64_t *v_ARRAY_INT64;
 #endif
   unsigned char *v_ARRAY_BYTE;
+  dbus_int16_t *v_ARRAY_INT16;
+  dbus_uint16_t *v_ARRAY_UINT16;
   dbus_int32_t *v_ARRAY_INT32;
+  dbus_uint32_t *v_ARRAY_UINT32;
   double *v_ARRAY_DOUBLE;
   DBusString t;
   double v_DOUBLE;
   double t_DOUBLE;
+  dbus_int16_t v_INT16;
+  dbus_uint16_t v_UINT16;
   dbus_int32_t v_INT32;
   dbus_uint32_t v_UINT32;
   dbus_int64_t v_INT64;
@@ -1600,6 +1735,14 @@ _dbus_marshal_test (void)
   if (!_DBUS_DOUBLES_BITWISE_EQUAL (t_DOUBLE, v_DOUBLE))
     _dbus_assert_not_reached ("got wrong double value");
 
+  /* Marshal signed 16 integers */
+  MARSHAL_TEST (INT16, DBUS_BIG_ENDIAN, -12345);
+  MARSHAL_TEST (INT16, DBUS_LITTLE_ENDIAN, -12345);
+
+  /* Marshal unsigned 16 integers */
+  MARSHAL_TEST (UINT16, DBUS_BIG_ENDIAN, 0x1234);
+  MARSHAL_TEST (UINT16, DBUS_LITTLE_ENDIAN, 0x1234);
+  
   /* Marshal signed integers */
   MARSHAL_TEST (INT32, DBUS_BIG_ENDIAN, -12345678);
   MARSHAL_TEST (INT32, DBUS_LITTLE_ENDIAN, -12345678);
@@ -1645,8 +1788,15 @@ _dbus_marshal_test (void)
   MARSHAL_TEST_STRCMP (SIGNATURE, DBUS_LITTLE_ENDIAN, "a(ii)");
 
   /* Arrays */
+  MARSHAL_TEST_FIXED_ARRAY (INT16, DBUS_BIG_ENDIAN, array2);
+  MARSHAL_TEST_FIXED_ARRAY (INT16, DBUS_LITTLE_ENDIAN, array2);
+  MARSHAL_TEST_FIXED_ARRAY (UINT16, DBUS_BIG_ENDIAN, array2);
+  MARSHAL_TEST_FIXED_ARRAY (UINT16, DBUS_LITTLE_ENDIAN, array2);
+  
   MARSHAL_TEST_FIXED_ARRAY (INT32, DBUS_BIG_ENDIAN, array4);
   MARSHAL_TEST_FIXED_ARRAY (INT32, DBUS_LITTLE_ENDIAN, array4);
+  MARSHAL_TEST_FIXED_ARRAY (UINT32, DBUS_BIG_ENDIAN, array4);
+  MARSHAL_TEST_FIXED_ARRAY (UINT32, DBUS_LITTLE_ENDIAN, array4);
 
   MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_BIG_ENDIAN, array1);
   MARSHAL_TEST_FIXED_ARRAY (BYTE, DBUS_LITTLE_ENDIAN, array1);
diff --git a/dbus/dbus-marshal-basic.h b/dbus/dbus-marshal-basic.h
index 375f2a3e..f25d38c2 100644
--- a/dbus/dbus-marshal-basic.h
+++ b/dbus/dbus-marshal-basic.h
@@ -41,6 +41,10 @@
 #define DBUS_COMPILER_BYTE_ORDER DBUS_LITTLE_ENDIAN
 #endif
 
+#define DBUS_UINT16_SWAP_LE_BE_CONSTANT(val)	((dbus_uint16_t) (      \
+    (dbus_uint16_t) ((dbus_uint16_t) (val) >> 8) |                      \
+    (dbus_uint16_t) ((dbus_uint16_t) (val) << 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) |     \
@@ -68,48 +72,66 @@
 	(dbus_uint64_t) DBUS_UINT64_CONSTANT (0xff00000000000000)) >> 56)))
 #endif /* DBUS_HAVE_INT64 */
 
+#define DBUS_UINT16_SWAP_LE_BE(val) (DBUS_UINT16_SWAP_LE_BE_CONSTANT (val))
+#define DBUS_INT16_SWAP_LE_BE(val)  ((dbus_int16_t)DBUS_UINT16_SWAP_LE_BE_CONSTANT (val))
+
 #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))
+#  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))
+
+#  define DBUS_INT16_TO_BE(val)	((dbus_int16_t) (val))
+#  define DBUS_UINT16_TO_BE(val)	((dbus_uint16_t) (val))
+#  define DBUS_INT16_TO_LE(val)	(DBUS_INT16_SWAP_LE_BE (val))
+#  define DBUS_UINT16_TO_LE(val)	(DBUS_UINT16_SWAP_LE_BE (val))
+#  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))
+#    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))
+
+#else /* WORDS_BIGENDIAN */
+
+#  define DBUS_INT16_TO_LE(val)	((dbus_int16_t) (val))
+#  define DBUS_UINT16_TO_LE(val)	((dbus_uint16_t) (val))
+#  define DBUS_INT16_TO_BE(val)	((dbus_int16_t) DBUS_UINT16_SWAP_LE_BE (val))
+#  define DBUS_UINT16_TO_BE(val)	(DBUS_UINT16_SWAP_LE_BE (val))
+#  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))
+#    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. */
+#define DBUS_INT16_FROM_LE(val)	 (DBUS_INT16_TO_LE (val))
+#define DBUS_UINT16_FROM_LE(val) (DBUS_UINT16_TO_LE (val))
+#define DBUS_INT16_FROM_BE(val)	 (DBUS_INT16_TO_BE (val))
+#define DBUS_UINT16_FROM_BE(val) (DBUS_UINT16_TO_BE (val))
 #define DBUS_INT32_FROM_LE(val)	 (DBUS_INT32_TO_LE (val))
 #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))
+#  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 */
 
 #ifndef DBUS_HAVE_INT64
@@ -131,11 +153,13 @@ typedef struct
  */
 typedef union
 {
+  dbus_int16_t  i16;   /**< as int16 */
+  dbus_uint16_t u16;   /**< as int16 */
   dbus_int32_t  i32;   /**< as int32 */
   dbus_uint32_t u32;   /**< as int32 */
 #ifdef DBUS_HAVE_INT64
-  dbus_int64_t  i64;   /**< as int32 */
-  dbus_uint64_t u64;   /**< as int32 */
+  dbus_int64_t  i64;   /**< as int64 */
+  dbus_uint64_t u64;   /**< as int64 */
 #else
   DBus8ByteStruct u64; /**< as 8-byte-struct */
 #endif
@@ -145,12 +169,22 @@ typedef union
 } DBusBasicValue;
 
 #ifdef DBUS_DISABLE_ASSERT
+#define _dbus_unpack_uint16(byte_order, data)           \
+   (((byte_order) == DBUS_LITTLE_ENDIAN) ?              \
+     DBUS_UINT16_FROM_LE (*(dbus_uint16_t*)(data)) :    \
+     DBUS_UINT16_FROM_BE (*(dbus_uint16_t*)(data)))
+
 #define _dbus_unpack_uint32(byte_order, data)           \
    (((byte_order) == DBUS_LITTLE_ENDIAN) ?              \
      DBUS_UINT32_FROM_LE (*(dbus_uint32_t*)(data)) :    \
      DBUS_UINT32_FROM_BE (*(dbus_uint32_t*)(data)))
 #endif
 
+#ifndef _dbus_unpack_uint16
+dbus_uint16_t _dbus_unpack_uint16 (int                  byte_order,
+                                   const unsigned char *data);
+#endif
+
 void          _dbus_pack_uint32   (dbus_uint32_t        value,
                                    int                  byte_order,
                                    unsigned char       *data);
diff --git a/dbus/dbus-marshal-byteswap.c b/dbus/dbus-marshal-byteswap.c
index 434d7e4b..7670ec45 100644
--- a/dbus/dbus-marshal-byteswap.c
+++ b/dbus/dbus-marshal-byteswap.c
@@ -47,6 +47,15 @@ byteswap_body_helper (DBusTypeReader       *reader,
           ++p;
           break;
 
+        case DBUS_TYPE_INT16:
+        case DBUS_TYPE_UINT16:
+          {
+            p = _DBUS_ALIGN_ADDRESS (p, 2);
+            *((dbus_uint16_t*)p) = DBUS_UINT16_SWAP_LE_BE (*((dbus_uint16_t*)p));
+            p += 2;
+          }
+          break;
+          
         case DBUS_TYPE_BOOLEAN:
         case DBUS_TYPE_INT32:
         case DBUS_TYPE_UINT32:
diff --git a/dbus/dbus-marshal-header.c b/dbus/dbus-marshal-header.c
index b5a8d3d7..f32e7aa8 100644
--- a/dbus/dbus-marshal-header.c
+++ b/dbus/dbus-marshal-header.c
@@ -672,7 +672,7 @@ _dbus_header_have_message_untrusted (int                max_message_length,
   dbus_uint32_t body_len_unsigned;
 
   _dbus_assert (start >= 0);
-  _dbus_assert (start < _DBUS_INT_MAX / 2);
+  _dbus_assert (start < _DBUS_INT32_MAX / 2);
   _dbus_assert (len >= 0);
 
   _dbus_assert (start == (int) _DBUS_ALIGN_VALUE (start, 8));
@@ -711,16 +711,16 @@ _dbus_header_have_message_untrusted (int                max_message_length,
   /* overflow should be impossible since the lengths aren't allowed to
    * be huge.
    */
-  _dbus_assert (max_message_length < _DBUS_INT_MAX / 2);
+  _dbus_assert (max_message_length < _DBUS_INT32_MAX / 2);
   if (body_len_unsigned + header_len_unsigned > (unsigned) max_message_length)
     {
       *validity = DBUS_INVALID_MESSAGE_TOO_LONG;
       return FALSE;
     }
 
-  _dbus_assert (body_len_unsigned < (unsigned) _DBUS_INT_MAX);
-  _dbus_assert (fields_array_len_unsigned < (unsigned) _DBUS_INT_MAX);
-  _dbus_assert (header_len_unsigned < (unsigned) _DBUS_INT_MAX);
+  _dbus_assert (body_len_unsigned < (unsigned) _DBUS_INT32_MAX);
+  _dbus_assert (fields_array_len_unsigned < (unsigned) _DBUS_INT32_MAX);
+  _dbus_assert (header_len_unsigned < (unsigned) _DBUS_INT32_MAX);
 
   *body_len = body_len_unsigned;
   *fields_array_len = fields_array_len_unsigned;
diff --git a/dbus/dbus-marshal-recursive-util.c b/dbus/dbus-marshal-recursive-util.c
index 08d030ab..c607b046 100644
--- a/dbus/dbus-marshal-recursive-util.c
+++ b/dbus/dbus-marshal-recursive-util.c
@@ -396,6 +396,26 @@ struct TestTypeNodeContainerClass
  * and by merging read_value and set_value into one function
  * taking a flag argument.
  */
+static dbus_bool_t int16_write_value       (TestTypeNode   *node,
+                                            DataBlock      *block,
+                                            DBusTypeWriter *writer,
+                                            int             seed);
+static dbus_bool_t int16_read_value        (TestTypeNode   *node,
+                                            DBusTypeReader *reader,
+                                            int             seed);
+static dbus_bool_t int16_set_value         (TestTypeNode   *node,
+                                            DBusTypeReader *reader,
+                                            DBusTypeReader *realign_root,
+                                            int             seed);
+static dbus_bool_t int16_write_multi       (TestTypeNode   *node,
+                                            DataBlock      *block,
+                                            DBusTypeWriter *writer,
+                                            int             seed,
+                                            int             count);
+static dbus_bool_t int16_read_multi        (TestTypeNode   *node,
+                                            DBusTypeReader *reader,
+                                            int             seed,
+                                            int             count);
 static dbus_bool_t int32_write_value       (TestTypeNode   *node,
                                             DataBlock      *block,
                                             DBusTypeWriter *writer,
@@ -533,6 +553,34 @@ static dbus_bool_t variant_set_value       (TestTypeNode   *node,
 static void        container_destroy       (TestTypeNode   *node);
 
 
+static const TestTypeNodeClass int16_class = {
+  DBUS_TYPE_INT16,
+  sizeof (TestTypeNode),
+  0,
+  NULL,
+  NULL,
+  int16_write_value,
+  int16_read_value,
+  int16_set_value,
+  NULL,
+  int16_write_multi,
+  int16_read_multi
+};
+
+static const TestTypeNodeClass uint16_class = {
+  DBUS_TYPE_UINT16,
+  sizeof (TestTypeNode),
+  0,
+  NULL,
+  NULL,
+  int16_write_value, /* recycle from int16 */
+  int16_read_value,  /* recycle from int16 */
+  int16_set_value,   /* recycle from int16 */
+  NULL,
+  int16_write_multi, /* recycle from int16 */
+  int16_read_multi   /* recycle from int16 */
+};
+
 static const TestTypeNodeClass int32_class = {
   DBUS_TYPE_INT32,
   sizeof (TestTypeNode),
@@ -819,6 +867,8 @@ static const TestTypeNodeClass variant_class = {
 
 static const TestTypeNodeClass* const
 basic_nodes[] = {
+  &int16_class,
+  &uint16_class,
   &int32_class,
   &uint32_class,
   &int64_class,
@@ -1978,6 +2028,142 @@ _dbus_marshal_recursive_test (void)
  */
 #define MAX_MULTI_COUNT 5
 
+#define SAMPLE_INT16           1234
+#define SAMPLE_INT16_ALTERNATE 6785
+static dbus_int16_t
+int16_from_seed (int seed)
+{
+  /* Generate an integer value that's predictable from seed.  We could
+   * just use seed itself, but that would only ever touch one byte of
+   * the int so would miss some kinds of bug.
+   */
+  dbus_int16_t v;
+
+  v = 42; /* just to quiet compiler afaik */
+  switch (seed % 5)
+    {
+    case 0:
+      v = SAMPLE_INT16;
+      break;
+    case 1:
+      v = SAMPLE_INT16_ALTERNATE;
+      break;
+    case 2:
+      v = -1;
+      break;
+    case 3:
+      v = _DBUS_INT16_MAX;
+      break;
+    case 4:
+      v = 1;
+      break;
+    }
+
+  if (seed > 1)
+    v *= seed; /* wraps around eventually, which is fine */
+
+  return v;
+}
+
+static dbus_bool_t
+int16_write_value (TestTypeNode   *node,
+                   DataBlock      *block,
+                   DBusTypeWriter *writer,
+                   int             seed)
+{
+  /* also used for uint16 */
+  dbus_int16_t v;
+
+  v = int16_from_seed (seed);
+
+  return _dbus_type_writer_write_basic (writer,
+                                        node->klass->typecode,
+                                        &v);
+}
+
+static dbus_bool_t
+int16_read_value (TestTypeNode   *node,
+                  DBusTypeReader *reader,
+                  int             seed)
+{
+  /* also used for uint16 */
+  dbus_int16_t v;
+
+  check_expected_type (reader, node->klass->typecode);
+
+  _dbus_type_reader_read_basic (reader,
+                                (dbus_int16_t*) &v);
+
+  _dbus_assert (v == int16_from_seed (seed));
+
+  return TRUE;
+}
+
+static dbus_bool_t
+int16_set_value (TestTypeNode   *node,
+                 DBusTypeReader *reader,
+                 DBusTypeReader *realign_root,
+                 int             seed)
+{
+  /* also used for uint16 */
+  dbus_int16_t v;
+
+  v = int16_from_seed (seed);
+
+  return _dbus_type_reader_set_basic (reader,
+                                      &v,
+                                      realign_root);
+}
+
+static dbus_bool_t
+int16_write_multi (TestTypeNode   *node,
+                   DataBlock      *block,
+                   DBusTypeWriter *writer,
+                   int             seed,
+                   int             count)
+{
+  /* also used for uint16 */
+  dbus_int16_t values[MAX_MULTI_COUNT];
+  dbus_int16_t *v_ARRAY_INT16 = values;
+  int i;
+
+  for (i = 0; i < count; ++i)
+    values[i] = int16_from_seed (seed + i);
+
+  return _dbus_type_writer_write_fixed_multi (writer,
+                                              node->klass->typecode,
+                                              &v_ARRAY_INT16, count);
+}
+
+static dbus_bool_t
+int16_read_multi (TestTypeNode   *node,
+                  DBusTypeReader *reader,
+                  int             seed,
+                  int             count)
+{
+  /* also used for uint16 */
+  dbus_int16_t *values;
+  int n_elements;
+  int i;
+
+  check_expected_type (reader, node->klass->typecode);
+
+  _dbus_type_reader_read_fixed_multi (reader,
+                                      &values,
+                                      &n_elements);
+
+  if (n_elements != count)
+    _dbus_warn ("got %d elements expected %d\n", n_elements, count);
+  _dbus_assert (n_elements == count);
+
+  for (i = 0; i < count; i++)
+    _dbus_assert (((int)_dbus_unpack_uint16 (reader->byte_order,
+                                             (const unsigned char*)values + (i * 2))) ==
+                  int16_from_seed (seed + i));
+
+  return TRUE;
+}
+
 
 #define SAMPLE_INT32           12345678
 #define SAMPLE_INT32_ALTERNATE 53781429
diff --git a/dbus/dbus-marshal-validate-util.c b/dbus/dbus-marshal-validate-util.c
index 6915c054..7a1648fa 100644
--- a/dbus/dbus-marshal-validate-util.c
+++ b/dbus/dbus-marshal-validate-util.c
@@ -68,7 +68,7 @@ static const ValidityTest signature_tests[] = {
   { "i", DBUS_VALID },
   { "ai", DBUS_VALID },
   { "(i)", DBUS_VALID },
-  { "q", DBUS_INVALID_UNKNOWN_TYPECODE },
+  { "w", DBUS_INVALID_UNKNOWN_TYPECODE },
   { "a", DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE },
   { "aaaaaa", DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE },
   { "ii(ii)a", DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE },
diff --git a/dbus/dbus-marshal-validate.c b/dbus/dbus-marshal-validate.c
index f15d2811..b26adb2c 100644
--- a/dbus/dbus-marshal-validate.c
+++ b/dbus/dbus-marshal-validate.c
@@ -57,7 +57,7 @@ _dbus_validate_signature_with_reason (const DBusString *type_str,
   int array_depth;
 
   _dbus_assert (type_str != NULL);
-  _dbus_assert (type_pos < _DBUS_INT_MAX - len);
+  _dbus_assert (type_pos < _DBUS_INT32_MAX - len);
   _dbus_assert (len >= 0);
   _dbus_assert (type_pos >= 0);
 
@@ -76,6 +76,8 @@ _dbus_validate_signature_with_reason (const DBusString *type_str,
         {
         case DBUS_TYPE_BYTE:
         case DBUS_TYPE_BOOLEAN:
+        case DBUS_TYPE_INT16:
+        case DBUS_TYPE_UINT16:
         case DBUS_TYPE_INT32:
         case DBUS_TYPE_UINT32:
         case DBUS_TYPE_INT64:
@@ -159,8 +161,10 @@ validate_body_helper (DBusTypeReader       *reader,
         case DBUS_TYPE_BYTE:
           ++p;
           break;
-
+          
         case DBUS_TYPE_BOOLEAN:
+        case DBUS_TYPE_INT16:
+        case DBUS_TYPE_UINT16:
         case DBUS_TYPE_INT32:
         case DBUS_TYPE_UINT32:
         case DBUS_TYPE_INT64:
diff --git a/dbus/dbus-message-util.c b/dbus/dbus-message-util.c
index 2d72f71e..c646ebf9 100644
--- a/dbus/dbus-message-util.c
+++ b/dbus/dbus-message-util.c
@@ -591,6 +591,8 @@ message_iter_test (DBusMessage *message)
   DBusMessageIter iter, array, array2;
   const char *v_STRING;
   double v_DOUBLE;
+  dbus_int16_t v_INT16;
+  dbus_uint16_t v_UINT16;
   dbus_int32_t v_INT32;
   dbus_uint32_t v_UINT32;
 #ifdef DBUS_HAVE_INT64
@@ -656,6 +658,8 @@ verify_test_message (DBusMessage *message)
 {
   DBusMessageIter iter;
   DBusError error;
+  dbus_int16_t our_int16;
+  dbus_uint16_t our_uint16;
   dbus_int32_t our_int;
   dbus_uint32_t our_uint;
   const char *our_str;
@@ -686,6 +690,8 @@ verify_test_message (DBusMessage *message)
 
   dbus_error_init (&error);
   if (!dbus_message_iter_get_args (&iter, &error,
+                                   DBUS_TYPE_INT16, &our_int16,
+                                   DBUS_TYPE_UINT16, &our_uint16,
 				   DBUS_TYPE_INT32, &our_int,
                                    DBUS_TYPE_UINT32, &our_uint,
 #ifdef DBUS_HAVE_INT64
@@ -720,6 +726,12 @@ verify_test_message (DBusMessage *message)
       _dbus_assert_not_reached ("Could not get arguments");
     }
 
+  if (our_int16 != -0x123)
+    _dbus_assert_not_reached ("16-bit integers differ!");
+
+  if (our_uint16 != 0x123)
+    _dbus_assert_not_reached ("16-bit uints differ!");
+  
   if (our_int != -0x12345678)
     _dbus_assert_not_reached ("integers differ!");
 
@@ -860,6 +872,8 @@ _dbus_message_test (const char *test_data_dir)
   const char *s;
   const char *v_STRING;
   double v_DOUBLE;
+  dbus_int16_t v_INT16;
+  dbus_uint16_t v_UINT16;
   dbus_int32_t v_INT32;
   dbus_uint32_t v_UINT32;
 #ifdef DBUS_HAVE_INT64
@@ -974,6 +988,8 @@ _dbus_message_test (const char *test_data_dir)
   _dbus_message_set_serial (message, 1);
   dbus_message_set_reply_serial (message, 5678);
 
+  v_INT16 = -0x123;
+  v_UINT16 = 0x123;
   v_INT32 = -0x12345678;
   v_UINT32 = 0x12300042;
 #ifdef DBUS_HAVE_INT64
@@ -987,6 +1003,8 @@ _dbus_message_test (const char *test_data_dir)
   v2_BYTE = 24;
 
   dbus_message_append_args (message,
+                            DBUS_TYPE_INT16, &v_INT16,
+                            DBUS_TYPE_UINT16, &v_UINT16,
 			    DBUS_TYPE_INT32, &v_INT32,
                             DBUS_TYPE_UINT32, &v_UINT32,
 #ifdef DBUS_HAVE_INT64
@@ -1017,6 +1035,8 @@ _dbus_message_test (const char *test_data_dir)
 			    DBUS_TYPE_INVALID);
 
   i = 0;
+  sig[i++] = DBUS_TYPE_INT16;
+  sig[i++] = DBUS_TYPE_UINT16;
   sig[i++] = DBUS_TYPE_INT32;
   sig[i++] = DBUS_TYPE_UINT32;
 #ifdef DBUS_HAVE_INT64
diff --git a/dbus/dbus-protocol.h b/dbus/dbus-protocol.h
index 9f569ec9..d0a3d64e 100644
--- a/dbus/dbus-protocol.h
+++ b/dbus/dbus-protocol.h
@@ -49,9 +49,12 @@ extern "C" {
 #define DBUS_TYPE_BYTE_AS_STRING           "y"
 #define DBUS_TYPE_BOOLEAN       ((int) 'b')
 #define DBUS_TYPE_BOOLEAN_AS_STRING        "b"
+#define DBUS_TYPE_INT16         ((int) 'n')
+#define DBUS_TYPE_INT16_AS_STRING          "n"
+#define DBUS_TYPE_UINT16        ((int) 'q')
+#define DBUS_TYPE_UINT16_AS_STRING         "q"
 #define DBUS_TYPE_INT32         ((int) 'i')
 #define DBUS_TYPE_INT32_AS_STRING          "i"
-
 #define DBUS_TYPE_UINT32        ((int) 'u')
 #define DBUS_TYPE_UINT32_AS_STRING         "u"
 #define DBUS_TYPE_INT64         ((int) 'x')
@@ -81,7 +84,7 @@ extern "C" {
 #define DBUS_TYPE_STRUCT_AS_STRING         "r"
 
 /* Does not count INVALID */
-#define DBUS_NUMBER_OF_TYPES    (13)
+#define DBUS_NUMBER_OF_TYPES    (15)
 
 /* characters other than typecodes that appear in type signatures */
 #define DBUS_STRUCT_BEGIN_CHAR   ((int) '(')
diff --git a/dbus/dbus-string-private.h b/dbus/dbus-string-private.h
index a4b7e8c3..d26aabe1 100644
--- a/dbus/dbus-string-private.h
+++ b/dbus/dbus-string-private.h
@@ -68,7 +68,7 @@ typedef struct
  * This is the maximum max length (and thus also the maximum length)
  * of a DBusString
  */
-#define _DBUS_STRING_MAX_MAX_LENGTH (_DBUS_INT_MAX - _DBUS_STRING_ALLOCATION_PADDING)
+#define _DBUS_STRING_MAX_MAX_LENGTH (_DBUS_INT32_MAX - _DBUS_STRING_ALLOCATION_PADDING)
 
 /**
  * Checks a bunch of assertions about a string object
diff --git a/dbus/dbus-string.c b/dbus/dbus-string.c
index 154193ce..f64d4746 100644
--- a/dbus/dbus-string.c
+++ b/dbus/dbus-string.c
@@ -974,6 +974,9 @@ _dbus_string_append (DBusString *str,
   return append (real, buffer, buffer_len);
 }
 
+/** assign 2 bytes from one string to another */
+#define ASSIGN_2_OCTETS(p, octets) \
+  *((dbus_uint16_t*)(p)) = *((dbus_uint16_t*)(octets));
 
 /** assign 4 bytes from one string to another */
 #define ASSIGN_4_OCTETS(p, octets) \
@@ -1052,6 +1055,30 @@ _dbus_string_append_8_aligned (DBusString         *str,
 #endif /* DBUS_BUILD_TESTS */
 
 /**
+ * Inserts 2 bytes aligned on a 2 byte boundary
+ * with any alignment padding initialized to 0.
+ *
+ * @param str the DBusString
+ * @param insert_at where to insert
+ * @param octets 2 bytes to insert
+ * @returns #FALSE if not enough memory.
+ */
+dbus_bool_t
+_dbus_string_insert_2_aligned (DBusString         *str,
+                               int                 insert_at,
+                               const unsigned char octets[4])
+{
+  DBUS_STRING_PREAMBLE (str);
+  
+  if (!align_insert_point_then_open_gap (str, &insert_at, 2, 2))
+    return FALSE;
+
+  ASSIGN_2_OCTETS (real->str + insert_at, octets);
+
+  return TRUE;
+}
+
+/**
  * Inserts 4 bytes aligned on a 4 byte boundary
  * with any alignment padding initialized to 0.
  *
@@ -1109,7 +1136,7 @@ _dbus_string_insert_8_aligned (DBusString         *str,
  *
  * @param str the DBusString
  * @param insert_at location to be aligned
- * @param alignment alignment boundary (1, 4, or 8)
+ * @param alignment alignment boundary (1, 2, 4, or 8)
  * @returns #FALSE if not enough memory.
  */
 dbus_bool_t
diff --git a/dbus/dbus-string.h b/dbus/dbus-string.h
index 52281210..84098226 100644
--- a/dbus/dbus-string.h
+++ b/dbus/dbus-string.h
@@ -156,6 +156,9 @@ dbus_bool_t   _dbus_string_append_printf         (DBusString        *str,
 dbus_bool_t   _dbus_string_append_printf_valist  (DBusString        *str,
                                                   const char        *format,
                                                   va_list            args);
+dbus_bool_t   _dbus_string_insert_2_aligned      (DBusString        *str,
+                                                  int                insert_at,
+                                                  const unsigned char octets[2]);
 dbus_bool_t   _dbus_string_insert_4_aligned      (DBusString        *str,
                                                   int                insert_at,
                                                   const unsigned char octets[4]);
diff --git a/dbus/dbus-test.c b/dbus/dbus-test.c
index eb2b8787..4fdd8ced 100644
--- a/dbus/dbus-test.c
+++ b/dbus/dbus-test.c
@@ -118,7 +118,7 @@ dbus_internal_do_not_use_run_tests (const char *test_data_dir)
 
   check_memleaks ();
 
-#if 0
+#if 1
   printf ("%s: running recursive marshalling tests\n", "dbus-test");
   if (!_dbus_marshal_recursive_test ())
     die ("recursive marshal");
@@ -140,7 +140,7 @@ dbus_internal_do_not_use_run_tests (const char *test_data_dir)
   
   check_memleaks ();
 
-#if 0
+#if 1
   printf ("%s: running memory pool tests\n", "dbus-test");
   if (!_dbus_mem_pool_test ())
     die ("memory pools");
diff --git a/dbus/dbus-transport.c b/dbus/dbus-transport.c
index 1a9da4a3..94d4a8a8 100644
--- a/dbus/dbus-transport.c
+++ b/dbus/dbus-transport.c
@@ -920,10 +920,10 @@ _dbus_transport_get_unix_user (DBusTransport *transport,
 {
   DBusCredentials auth_identity;
 
-  *uid = _DBUS_INT_MAX; /* better than some root or system user in
-                         * case of bugs in the caller. Caller should
-                         * never use this value on purpose, however.
-                         */
+  *uid = _DBUS_INT32_MAX; /* better than some root or system user in
+                           * case of bugs in the caller. Caller should
+                           * never use this value on purpose, however.
+                           */
   
   if (!transport->authenticated)
     return FALSE;
diff --git a/dbus/dbus-types.h b/dbus/dbus-types.h
index 55ddf434..d45c2516 100644
--- a/dbus/dbus-types.h
+++ b/dbus/dbus-types.h
@@ -28,9 +28,8 @@
 #define DBUS_TYPES_H
 
 #include <stddef.h>
+#include <dbus/dbus-arch-deps.h>
 
-typedef unsigned int   dbus_uint32_t;
-typedef int            dbus_int32_t;
 typedef dbus_uint32_t  dbus_unichar_t;
 /* boolean size must be fixed at 4 bytes due to wire protocol! */
 typedef dbus_uint32_t  dbus_bool_t;
diff --git a/glib/dbus-gparser.c b/glib/dbus-gparser.c
index 2318c015..478dcdf3 100644
--- a/glib/dbus-gparser.c
+++ b/glib/dbus-gparser.c
@@ -437,6 +437,10 @@ basic_type_from_string (const char *str)
 {
   if (strcmp (str, "string") == 0)
     return DBUS_TYPE_STRING;
+  else if (strcmp (str, "int16") == 0)
+    return DBUS_TYPE_INT16;
+  else if (strcmp (str, "uint16") == 0)
+    return DBUS_TYPE_UINT16;
   else if (strcmp (str, "int32") == 0)
     return DBUS_TYPE_INT32;
   else if (strcmp (str, "uint32") == 0)
diff --git a/glib/dbus-gutils.c b/glib/dbus-gutils.c
index 9e4a5cd2..ff48e7f1 100644
--- a/glib/dbus-gutils.c
+++ b/glib/dbus-gutils.c
@@ -88,6 +88,10 @@ _dbus_gutils_type_to_string (int type)
       return "boolean";
     case DBUS_TYPE_BYTE:
       return "byte";
+    case DBUS_TYPE_INT16:
+      return "int16";
+    case DBUS_TYPE_UINT16:
+      return "uint16";
     case DBUS_TYPE_INT32:
       return "int32";
     case DBUS_TYPE_UINT32:
diff --git a/glib/dbus-gvalue.c b/glib/dbus-gvalue.c
index 1fed0cf7..e2bf40b2 100644
--- a/glib/dbus-gvalue.c
+++ b/glib/dbus-gvalue.c
@@ -40,12 +40,29 @@ dbus_gvalue_demarshal (DBusMessageIter *iter, GValue *value)
   switch (dbus_message_iter_get_arg_type (iter))
     {
       MAP_BASIC (BOOLEAN, BOOLEAN);
-      MAP_BASIC (BYTE, UCHAR);
-      MAP_BASIC (INT32, INT);
-      MAP_BASIC (UINT32, UINT);
-      MAP_BASIC (INT64, INT64);
-      MAP_BASIC (UINT64, UINT64);
-      MAP_BASIC (DOUBLE, DOUBLE);
+      MAP_BASIC (BYTE,    UCHAR);
+      MAP_BASIC (INT32,   INT);
+      MAP_BASIC (UINT32,  UINT);
+      MAP_BASIC (INT64,   INT64);
+      MAP_BASIC (UINT64,  UINT64);
+      MAP_BASIC (DOUBLE,  DOUBLE);
+
+    case DBUS_TYPE_INT16:
+      {
+        dbus_int16_t v;
+        g_value_init (value, G_TYPE_INT);
+        dbus_message_iter_get_basic (iter, &v);
+        g_value_set_int (value, v);
+      }
+      break;
+    case DBUS_TYPE_UINT16:
+      {
+        dbus_uint16_t v;
+        g_value_init (value, G_TYPE_UINT);
+        dbus_message_iter_get_basic (iter, &v);
+        g_value_set_uint (value, v);
+      }
+      break;
       
     case DBUS_TYPE_STRING:
     case DBUS_TYPE_OBJECT_PATH: