dbus/dbus-signature.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* dbus-signature.c  Routines for reading recursive type signatures
   3  *
   4  * Copyright (C) 2005 Red Hat, Inc.
   5  *
   6  * Licensed under the Academic Free License version 2.1
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  21  *
  22  */
  23
  24 #include <config.h>
  25
  26 #include "dbus-signature.h"
  27 #include "dbus-marshal-recursive.h"
  28 #include "dbus-marshal-basic.h"
  29 #include "dbus-internals.h"
  30 #include "dbus-test.h"
  31
  32 /**
  33  * Implementation details of #DBusSignatureIter, all fields are private
  34  */
  35 typedef struct
  36 {
  37   const char *pos;           /**< current position in the signature string */
  38   unsigned int finished : 1; /**< true if we are at the end iter */
  39   unsigned int in_array : 1; /**< true if we are a subiterator pointing to an array's element type */
  40 } DBusSignatureRealIter;
  41
  42 /** macro that checks whether a typecode is a container type */
  43 #define TYPE_IS_CONTAINER(typecode)             \
  44     ((typecode) == DBUS_TYPE_STRUCT ||          \
  45      (typecode) == DBUS_TYPE_DICT_ENTRY ||      \
  46      (typecode) == DBUS_TYPE_VARIANT ||         \
  47      (typecode) == DBUS_TYPE_ARRAY)
  48
  49
  50 /**
  51  * @defgroup DBusSignature Type signature parsing
  52  * @ingroup  DBus
  53  * @brief Parsing D-Bus type signatures
  54  * @{
  55  */
  56
  57 /**
  58  * Initializes a #DBusSignatureIter for reading a type signature.  This
  59  * function is not safe to use on invalid signatures; be sure to
  60  * validate potentially invalid signatures with dbus_signature_validate
  61  * before using this function.
  62  *
  63  * @param iter pointer to an iterator to initialize
  64  * @param signature the type signature
  65  */
  66 void
  67 dbus_signature_iter_init (DBusSignatureIter *iter,
  68                           const char        *signature)
  69 {
  70   DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
  71
  72   real_iter->pos = signature;
  73   real_iter->finished = FALSE;
  74   real_iter->in_array = FALSE;
  75 }
  76
  77 /**
  78  * Returns the current type pointed to by the iterator.
  79  * If the iterator is pointing at a type code such as 's', then
  80  * it will be returned directly.
  81  *
  82  * However, when the parser encounters a container type start
  83  * character such as '(' for a structure, the corresponding type for
  84  * the container will be returned, e.g.  DBUS_TYPE_STRUCT, not '('.
  85  * In this case, you should initialize a sub-iterator with
  86  * dbus_signature_iter_recurse() to parse the container type.
  87  *
  88  * @param iter pointer to an iterator
  89  * @returns current type (e.g. #DBUS_TYPE_STRING, #DBUS_TYPE_ARRAY)
  90  */
  91 int
  92 dbus_signature_iter_get_current_type (const DBusSignatureIter *iter)
  93 {
  94   DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
  95
  96   return _dbus_first_type_in_signature_c_str (real_iter->pos, 0);
  97 }
  98
  99 /**
 100  * Returns the signature of the single complete type starting at the
 101  * given iterator.
 102  *
 103  * For example, if the iterator is pointing at the start of "(ii)ii"
 104  * (which is "a struct of two ints, followed by an int, followed by an
 105  * int"), then "(ii)" would be returned. If the iterator is pointing at
 106  * one of the "i" then just that "i" would be returned.
 107  *
 108  * @param iter pointer to an iterator
 109  * @returns current signature; or #NULL if no memory.  Should be freed with dbus_free()
 110  */
 111 char *
 112 dbus_signature_iter_get_signature (const DBusSignatureIter *iter)
 113 {
 114   DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
 115   DBusString str;
 116   char *ret;
 117   int pos;
 118
 119   if (!_dbus_string_init (&str))
 120     return NULL;
 121
 122   pos = 0;
 123   _dbus_type_signature_next (real_iter->pos, &pos);
 124
 125   if (!_dbus_string_append_len (&str, real_iter->pos, pos))
 126     return NULL;
 127   if (!_dbus_string_steal_data (&str, &ret))
 128     ret = NULL;
 129   _dbus_string_free (&str);
 130
 131   return ret;
 132 }
 133
 134 /**
 135  * Convenience function for returning the element type of an array;
 136  * This function allows you to avoid initializing a sub-iterator and
 137  * getting its current type.
 138  *
 139  * Undefined behavior results if you invoke this function when the
 140  * current type of the iterator is not #DBUS_TYPE_ARRAY.
 141  *
 142  * @param iter pointer to an iterator
 143  * @returns current array element type
 144  */
 145 int
 146 dbus_signature_iter_get_element_type (const DBusSignatureIter *iter)
 147 {
 148   DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
 149
 150   _dbus_return_val_if_fail (dbus_signature_iter_get_current_type (iter) == DBUS_TYPE_ARRAY, DBUS_TYPE_INVALID);
 151
 152   return _dbus_first_type_in_signature_c_str (real_iter->pos, 1);
 153 }
 154
 155 /**
 156  * Skip to the next value on this "level". e.g. the next field in a
 157  * struct, the next value in an array. Returns #FALSE at the end of the
 158  * current container.
 159  *
 160  * @param iter the iterator
 161  * @returns FALSE if nothing more to read at or below this level
 162  */
 163 dbus_bool_t
 164 dbus_signature_iter_next (DBusSignatureIter *iter)
 165 {
 166   DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
 167
 168   if (real_iter->finished)
 169     return FALSE;
 170   else
 171     {
 172       int pos;
 173
 174       if (real_iter->in_array)
 175         {
 176           real_iter->finished = TRUE;
 177           return FALSE;
 178         }
 179
 180       pos = 0;
 181       _dbus_type_signature_next (real_iter->pos, &pos);
 182       real_iter->pos += pos;
 183
 184       if (*real_iter->pos == DBUS_STRUCT_END_CHAR
 185           || *real_iter->pos == DBUS_DICT_ENTRY_END_CHAR)
 186         {
 187           real_iter->finished = TRUE;
 188           return FALSE;
 189         }
 190
 191       return *real_iter->pos != DBUS_TYPE_INVALID;
 192     }
 193 }
 194
 195 /**
 196  * Initialize a new iterator pointing to the first type in the current
 197  * container.
 198  *
 199  * The results are undefined when calling this if the current type is
 200  * a non-container (i.e. if dbus_type_is_container() returns #FALSE
 201  * for the result of dbus_signature_iter_get_current_type()).
 202  *
 203  * @param iter the current interator
 204  * @param subiter an iterator to initialize pointing to the first child
 205  */
 206 void
 207 dbus_signature_iter_recurse (const DBusSignatureIter *iter,
 208                              DBusSignatureIter       *subiter)
 209 {
 210   DBusSignatureRealIter *real_iter = (DBusSignatureRealIter *) iter;
 211   DBusSignatureRealIter *real_sub_iter = (DBusSignatureRealIter *) subiter;
 212
 213   _dbus_return_if_fail (dbus_type_is_container (dbus_signature_iter_get_current_type (iter)));
 214
 215   *real_sub_iter = *real_iter;
 216   real_sub_iter->in_array = FALSE;
 217   real_sub_iter->pos++;
 218
 219   if (dbus_signature_iter_get_current_type (iter) == DBUS_TYPE_ARRAY)
 220     real_sub_iter->in_array = TRUE;
 221 }
 222
 223 /**
 224  * Check a type signature for validity. Remember that #NULL can always
 225  * be passed instead of a DBusError*, if you don't care about having
 226  * an error name and message.
 227  *
 228  * @param signature a potentially invalid type signature
 229  * @param error error return
 230  * @returns #TRUE if signature is valid or #FALSE if an error is set
 231  */
 232 dbus_bool_t
 233 dbus_signature_validate (const char       *signature,
 234                          DBusError        *error)
 235
 236 {
 237   DBusString str;
 238   DBusValidity reason;
 239
 240   _dbus_string_init_const (&str, signature);
 241   reason = _dbus_validate_signature_with_reason (&str, 0, _dbus_string_get_length (&str));
 242
 243   if (reason == DBUS_VALID)
 244     return TRUE;
 245   else
 246     {
 247       dbus_set_error (error, DBUS_ERROR_INVALID_SIGNATURE, "%s",
 248           _dbus_validity_to_error_message (reason));
 249       return FALSE;
 250     }
 251 }
 252
 253 /**
 254  * Check that a type signature is both valid and contains exactly one
 255  * complete type. "One complete type" means a single basic type,
 256  * array, struct, or dictionary, though the struct or array may be
 257  * arbitrarily recursive and complex. More than one complete type
 258  * would mean for example "ii" or two integers in sequence.
 259  *
 260  * @param signature a potentially invalid type signature
 261  * @param error error return
 262  * @returns #TRUE if signature is valid and has exactly one complete type
 263  */
 264 dbus_bool_t
 265 dbus_signature_validate_single (const char       *signature,
 266                                 DBusError        *error)
 267 {
 268   DBusSignatureIter iter;
 269
 270   if (!dbus_signature_validate (signature, error))
 271     return FALSE;
 272
 273   dbus_signature_iter_init (&iter, signature);
 274   if (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_INVALID)
 275     goto lose;
 276   if (!dbus_signature_iter_next (&iter))
 277     return TRUE;
 278  lose:
 279   dbus_set_error (error, DBUS_ERROR_INVALID_SIGNATURE, "Exactly one complete type required in signature");
 280   return FALSE;
 281 }
 282
 283 /**
 284  * A "container type" can contain basic types, or nested
 285  * container types. #DBUS_TYPE_INVALID is not a container type.
 286  *
 287  * It is an error to pass an invalid type-code, other than DBUS_TYPE_INVALID,
 288  * to this function. The valid type-codes are defined by dbus-protocol.h
 289  * and can be checked with dbus_type_is_valid().
 290  *
 291  * @param typecode either a valid type-code or DBUS_TYPE_INVALID
 292  * @returns #TRUE if type is a container
 293  */
 294 dbus_bool_t
 295 dbus_type_is_container (int typecode)
 296 {
 297   /* only reasonable (non-line-noise) typecodes are allowed */
 298   _dbus_return_val_if_fail (dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,
 299                             FALSE);
 300   return TYPE_IS_CONTAINER (typecode);
 301 }
 302
 303 /**
 304  * A "basic type" is a somewhat arbitrary concept, but the intent is
 305  * to include those types that are fully-specified by a single
 306  * typecode, with no additional type information or nested values. So
 307  * all numbers and strings are basic types and structs, arrays, and
 308  * variants are not basic types.  #DBUS_TYPE_INVALID is not a basic
 309  * type.
 310  *
 311  * It is an error to pass an invalid type-code, other than DBUS_TYPE_INVALID,
 312  * to this function. The valid type-codes are defined by dbus-protocol.h
 313  * and can be checked with dbus_type_is_valid().
 314  *
 315  * @param typecode either a valid type-code or DBUS_TYPE_INVALID
 316  * @returns #TRUE if type is basic
 317  */
 318 dbus_bool_t
 319 dbus_type_is_basic (int typecode)
 320 {
 321   /* only reasonable (non-line-noise) typecodes are allowed */
 322   _dbus_return_val_if_fail (dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,
 323                             FALSE);
 324
 325   /* everything that isn't invalid or a container */
 326   return !(typecode == DBUS_TYPE_INVALID || TYPE_IS_CONTAINER (typecode));
 327 }
 328
 329 /**
 330  * Tells you whether values of this type can change length if you set
 331  * them to some other value. For this purpose, you assume that the
 332  * first byte of the old and new value would be in the same location,
 333  * so alignment padding is not a factor.
 334  *
 335  * This function is useful to determine whether
 336  * dbus_message_iter_get_fixed_array() may be used.
 337  *
 338  * Some structs are fixed-size (if they contain only fixed-size types)
 339  * but struct is not considered a fixed type for purposes of this
 340  * function.
 341  *
 342  * It is an error to pass an invalid type-code, other than DBUS_TYPE_INVALID,
 343  * to this function. The valid type-codes are defined by dbus-protocol.h
 344  * and can be checked with dbus_type_is_valid().
 345  *
 346  * @param typecode either a valid type-code or DBUS_TYPE_INVALID
 347  * @returns #FALSE if the type can occupy different lengths
 348  */
 349 dbus_bool_t
 350 dbus_type_is_fixed (int typecode)
 351 {
 352   /* only reasonable (non-line-noise) typecodes are allowed */
 353   _dbus_return_val_if_fail (dbus_type_is_valid (typecode) || typecode == DBUS_TYPE_INVALID,
 354                             FALSE);
 355
 356   switch (typecode)
 357     {
 358     case DBUS_TYPE_BYTE:
 359     case DBUS_TYPE_BOOLEAN:
 360     case DBUS_TYPE_INT16:
 361     case DBUS_TYPE_UINT16:
 362     case DBUS_TYPE_INT32:
 363     case DBUS_TYPE_UINT32:
 364     case DBUS_TYPE_INT64:
 365     case DBUS_TYPE_UINT64:
 366     case DBUS_TYPE_DOUBLE:
 367     case DBUS_TYPE_UNIX_FD:
 368       return TRUE;
 369     default:
 370       return FALSE;
 371     }
 372 }
 373
 374 /**
 375  * Return #TRUE if the argument is a valid typecode.
 376  * #DBUS_TYPE_INVALID surprisingly enough is not considered valid, and
 377  * random unknown bytes aren't either. This function is safe with
 378  * untrusted data.
 379  *
 380  * @param typecode a potential type-code
 381  * @returns #TRUE if valid
 382  */
 383 dbus_bool_t
 384 dbus_type_is_valid (int typecode)
 385 {
 386   switch (typecode)
 387     {
 388     case DBUS_TYPE_BYTE:
 389     case DBUS_TYPE_BOOLEAN:
 390     case DBUS_TYPE_INT16:
 391     case DBUS_TYPE_UINT16:
 392     case DBUS_TYPE_INT32:
 393     case DBUS_TYPE_UINT32:
 394     case DBUS_TYPE_INT64:
 395     case DBUS_TYPE_UINT64:
 396     case DBUS_TYPE_DOUBLE:
 397     case DBUS_TYPE_STRING:
 398     case DBUS_TYPE_OBJECT_PATH:
 399     case DBUS_TYPE_SIGNATURE:
 400     case DBUS_TYPE_ARRAY:
 401     case DBUS_TYPE_STRUCT:
 402     case DBUS_TYPE_DICT_ENTRY:
 403     case DBUS_TYPE_VARIANT:
 404     case DBUS_TYPE_UNIX_FD:
 405       return TRUE;
 406
 407     default:
 408       return FALSE;
 409     }
 410 }
 411
 412 /** @} */ /* end of DBusSignature group */
 413
 414 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
 415
 416 /**
 417  * @ingroup DBusSignatureInternals
 418  * Unit test for DBusSignature.
 419  *
 420  * @returns #TRUE on success.
 421  */
 422 dbus_bool_t
 423 _dbus_signature_test (void)
 424 {
 425   DBusSignatureIter iter;
 426   DBusSignatureIter subiter;
 427   DBusSignatureIter subsubiter;
 428   DBusSignatureIter subsubsubiter;
 429   const char *sig;
 430   dbus_bool_t boolres;
 431
 432   _DBUS_STATIC_ASSERT (sizeof (DBusSignatureIter) >= sizeof (DBusSignatureRealIter));
 433
 434   sig = "";
 435   _dbus_assert (dbus_signature_validate (sig, NULL));
 436   _dbus_assert (!dbus_signature_validate_single (sig, NULL));
 437   dbus_signature_iter_init (&iter, sig);
 438   _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_INVALID);
 439
 440   sig = DBUS_TYPE_STRING_AS_STRING;
 441   _dbus_assert (dbus_signature_validate (sig, NULL));
 442   _dbus_assert (dbus_signature_validate_single (sig, NULL));
 443   dbus_signature_iter_init (&iter, sig);
 444   _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRING);
 445
 446   sig = DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
 447   _dbus_assert (dbus_signature_validate (sig, NULL));
 448   dbus_signature_iter_init (&iter, sig);
 449   _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRING);
 450   boolres = dbus_signature_iter_next (&iter);
 451   _dbus_assert (boolres);
 452   _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_BYTE);
 453
 454   sig = DBUS_TYPE_UINT16_AS_STRING
 455     DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 456     DBUS_TYPE_STRING_AS_STRING
 457     DBUS_TYPE_UINT32_AS_STRING
 458     DBUS_TYPE_VARIANT_AS_STRING
 459     DBUS_TYPE_DOUBLE_AS_STRING
 460     DBUS_STRUCT_END_CHAR_AS_STRING;
 461   _dbus_assert (dbus_signature_validate (sig, NULL));
 462   dbus_signature_iter_init (&iter, sig);
 463   _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_UINT16);
 464   boolres = dbus_signature_iter_next (&iter);
 465   _dbus_assert (boolres);
 466   _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRUCT);
 467   dbus_signature_iter_recurse (&iter, &subiter);
 468   _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_STRING);
 469   boolres = dbus_signature_iter_next (&subiter);
 470   _dbus_assert (boolres);
 471   _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_UINT32);
 472   boolres = dbus_signature_iter_next (&subiter);
 473   _dbus_assert (boolres);
 474   _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_VARIANT);
 475   boolres = dbus_signature_iter_next (&subiter);
 476   _dbus_assert (boolres);
 477   _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_DOUBLE);
 478
 479   sig = DBUS_TYPE_UINT16_AS_STRING
 480     DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 481     DBUS_TYPE_UINT32_AS_STRING
 482     DBUS_TYPE_BYTE_AS_STRING
 483     DBUS_TYPE_ARRAY_AS_STRING
 484     DBUS_TYPE_ARRAY_AS_STRING
 485     DBUS_TYPE_DOUBLE_AS_STRING
 486     DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 487     DBUS_TYPE_BYTE_AS_STRING
 488     DBUS_STRUCT_END_CHAR_AS_STRING
 489     DBUS_STRUCT_END_CHAR_AS_STRING;
 490   _dbus_assert (dbus_signature_validate (sig, NULL));
 491   dbus_signature_iter_init (&iter, sig);
 492   _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_UINT16);
 493   boolres = dbus_signature_iter_next (&iter);
 494   _dbus_assert (boolres);
 495   _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_STRUCT);
 496   dbus_signature_iter_recurse (&iter, &subiter);
 497   _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_UINT32);
 498   boolres = dbus_signature_iter_next (&subiter);
 499   _dbus_assert (boolres);
 500   _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_BYTE);
 501   boolres = dbus_signature_iter_next (&subiter);
 502   _dbus_assert (boolres);
 503   _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_ARRAY);
 504   _dbus_assert (dbus_signature_iter_get_element_type (&subiter) == DBUS_TYPE_ARRAY);
 505
 506   dbus_signature_iter_recurse (&subiter, &subsubiter);
 507   _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_ARRAY);
 508   _dbus_assert (dbus_signature_iter_get_element_type (&subsubiter) == DBUS_TYPE_DOUBLE);
 509
 510   dbus_signature_iter_recurse (&subsubiter, &subsubsubiter);
 511   _dbus_assert (dbus_signature_iter_get_current_type (&subsubsubiter) == DBUS_TYPE_DOUBLE);
 512   boolres = dbus_signature_iter_next (&subiter);
 513   _dbus_assert (boolres);
 514   _dbus_assert (dbus_signature_iter_get_current_type (&subiter) == DBUS_TYPE_STRUCT);
 515   dbus_signature_iter_recurse (&subiter, &subsubiter);
 516   _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_BYTE);
 517
 518   sig = DBUS_TYPE_ARRAY_AS_STRING
 519     DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 520     DBUS_TYPE_INT16_AS_STRING
 521     DBUS_TYPE_STRING_AS_STRING
 522     DBUS_DICT_ENTRY_END_CHAR_AS_STRING
 523     DBUS_TYPE_VARIANT_AS_STRING;
 524   _dbus_assert (dbus_signature_validate (sig, NULL));
 525   _dbus_assert (!dbus_signature_validate_single (sig, NULL));
 526   dbus_signature_iter_init (&iter, sig);
 527   _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_ARRAY);
 528   _dbus_assert (dbus_signature_iter_get_element_type (&iter) == DBUS_TYPE_DICT_ENTRY);
 529
 530   dbus_signature_iter_recurse (&iter, &subiter);
 531   dbus_signature_iter_recurse (&subiter, &subsubiter);
 532   _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_INT16);
 533   boolres = dbus_signature_iter_next (&subsubiter);
 534   _dbus_assert (boolres);
 535   _dbus_assert (dbus_signature_iter_get_current_type (&subsubiter) == DBUS_TYPE_STRING);
 536   boolres = dbus_signature_iter_next (&subsubiter);
 537   _dbus_assert (!boolres);
 538
 539   boolres = dbus_signature_iter_next (&iter);
 540   _dbus_assert (boolres);
 541   _dbus_assert (dbus_signature_iter_get_current_type (&iter) == DBUS_TYPE_VARIANT);
 542   boolres = dbus_signature_iter_next (&iter);
 543   _dbus_assert (!boolres);
 544
 545   sig = DBUS_TYPE_DICT_ENTRY_AS_STRING;
 546   _dbus_assert (!dbus_signature_validate (sig, NULL));
 547
 548   sig = DBUS_TYPE_ARRAY_AS_STRING;
 549   _dbus_assert (!dbus_signature_validate (sig, NULL));
 550
 551   sig = DBUS_TYPE_UINT32_AS_STRING
 552     DBUS_TYPE_ARRAY_AS_STRING;
 553   _dbus_assert (!dbus_signature_validate (sig, NULL));
 554
 555   sig = DBUS_TYPE_ARRAY_AS_STRING
 556     DBUS_TYPE_DICT_ENTRY_AS_STRING;
 557   _dbus_assert (!dbus_signature_validate (sig, NULL));
 558
 559   sig = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING;
 560   _dbus_assert (!dbus_signature_validate (sig, NULL));
 561
 562   sig = DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
 563   _dbus_assert (!dbus_signature_validate (sig, NULL));
 564
 565   sig = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 566     DBUS_TYPE_INT32_AS_STRING;
 567   _dbus_assert (!dbus_signature_validate (sig, NULL));
 568
 569   sig = DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
 570     DBUS_TYPE_INT32_AS_STRING
 571     DBUS_TYPE_STRING_AS_STRING;
 572   _dbus_assert (!dbus_signature_validate (sig, NULL));
 573
 574   sig = DBUS_STRUCT_END_CHAR_AS_STRING
 575     DBUS_STRUCT_BEGIN_CHAR_AS_STRING;
 576   _dbus_assert (!dbus_signature_validate (sig, NULL));
 577
 578   sig = DBUS_STRUCT_BEGIN_CHAR_AS_STRING
 579     DBUS_TYPE_BOOLEAN_AS_STRING;
 580   _dbus_assert (!dbus_signature_validate (sig, NULL));
 581   return TRUE;
 582 #if 0
 583  oom:
 584   _dbus_assert_not_reached ("out of memory");
 585   return FALSE;
 586 #endif
 587 }
 588
 589 #endif
 590