dbus/dbus-marshal-validate-util.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* dbus-marshal-validate-util.c Would be in dbus-marshal-validate.c, but only used by tests/bus
   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 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
  26
  27 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  28
  29 #include "dbus-internals.h"
  30 #include "dbus-marshal-validate.h"
  31 #include "dbus-marshal-recursive.h"
  32
  33 #include "dbus-test.h"
  34 #include <stdio.h>
  35
  36 typedef struct
  37 {
  38   const char *data;
  39   DBusValidity expected;
  40 } ValidityTest;
  41
  42 static void
  43 run_validity_tests (const ValidityTest *tests,
  44                     int                 n_tests,
  45                     DBusValidity (* func) (const DBusString*,int,int))
  46 {
  47   int i;
  48
  49   for (i = 0; i < n_tests; i++)
  50     {
  51       DBusString str;
  52       DBusValidity v;
  53
  54       _dbus_string_init_const (&str, tests[i].data);
  55
  56       v = (*func) (&str, 0, _dbus_string_get_length (&str));
  57
  58       if (v != tests[i].expected)
  59         {
  60           _dbus_warn ("Improper validation result %d for '%s'\n",
  61                       v, tests[i].data);
  62           _dbus_assert_not_reached ("test failed");
  63         }
  64
  65       ++i;
  66     }
  67 }
  68
  69 static const ValidityTest signature_tests[] = {
  70   { "", DBUS_VALID },
  71   { "i", DBUS_VALID },
  72   { "ai", DBUS_VALID },
  73   { "(i)", DBUS_VALID },
  74   { "w", DBUS_INVALID_UNKNOWN_TYPECODE },
  75   { "a", DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE },
  76   { "aaaaaa", DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE },
  77   { "ii(ii)a", DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE },
  78   { "ia", DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE },
  79   /* DBUS_INVALID_SIGNATURE_TOO_LONG, */ /* too hard to test this way */
  80   { "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
  81     DBUS_INVALID_EXCEEDED_MAXIMUM_ARRAY_RECURSION },
  82   { "((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((ii))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))",
  83     DBUS_INVALID_EXCEEDED_MAXIMUM_STRUCT_RECURSION },
  84   { ")", DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED },
  85   { "i)", DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED },
  86   { "a)", DBUS_INVALID_STRUCT_ENDED_BUT_NOT_STARTED },
  87   { "(", DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED },
  88   { "(i", DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED },
  89   { "(iiiii", DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED },
  90   { "(ai", DBUS_INVALID_STRUCT_STARTED_BUT_NOT_ENDED },
  91   { "()", DBUS_INVALID_STRUCT_HAS_NO_FIELDS },
  92   { "(())", DBUS_INVALID_STRUCT_HAS_NO_FIELDS },
  93   { "a()", DBUS_INVALID_STRUCT_HAS_NO_FIELDS },
  94   { "i()", DBUS_INVALID_STRUCT_HAS_NO_FIELDS },
  95   { "()i", DBUS_INVALID_STRUCT_HAS_NO_FIELDS },
  96   { "(a)", DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE },
  97   { "a{ia}", DBUS_INVALID_MISSING_ARRAY_ELEMENT_TYPE },
  98   { "a{}", DBUS_INVALID_DICT_ENTRY_HAS_NO_FIELDS },
  99   { "a{aii}", DBUS_INVALID_DICT_KEY_MUST_BE_BASIC_TYPE },
 100   /* { "a{i}", DBUS_INVALID_DICT_ENTRY_HAS_ONLY_ONE_FIELD }, */
 101   /* { "{is}", DBUS_INVALID_DICT_ENTRY_NOT_INSIDE_ARRAY }, */
 102   /* { "a{isi}", DBUS_INVALID_DICT_ENTRY_HAS_TOO_MANY_FIELDS }, */
 103 };
 104
 105 dbus_bool_t
 106 _dbus_marshal_validate_test (void)
 107 {
 108   DBusString str;
 109   int i;
 110
 111   const char *valid_paths[] = {
 112     "/",
 113     "/foo/bar",
 114     "/foo",
 115     "/foo/bar/baz"
 116   };
 117   const char *invalid_paths[] = {
 118     "bar",
 119     "bar/baz",
 120     "/foo/bar/",
 121     "/foo/"
 122     "foo/",
 123     "boo//blah",
 124     "//",
 125     "///",
 126     "foo///blah/",
 127     "Hello World",
 128     "",
 129     "   ",
 130     "foo bar"
 131   };
 132
 133   const char *valid_interfaces[] = {
 134     "org.freedesktop.Foo",
 135     "Bar.Baz",
 136     "Blah.Blah.Blah.Blah.Blah",
 137     "a.b",
 138     "a.b.c.d.e.f.g",
 139     "a0.b1.c2.d3.e4.f5.g6",
 140     "abc123.foo27"
 141   };
 142   const char *invalid_interfaces[] = {
 143     ".",
 144     "",
 145     "..",
 146     ".Foo.Bar",
 147     "..Foo.Bar",
 148     "Foo.Bar.",
 149     "Foo.Bar..",
 150     "Foo",
 151     "9foo.bar.baz",
 152     "foo.bar..baz",
 153     "foo.bar...baz",
 154     "foo.bar.b..blah",
 155     ":",
 156     ":0-1",
 157     "10",
 158     ":11.34324",
 159     "0.0.0",
 160     "0..0",
 161     "foo.Bar.%",
 162     "foo.Bar!!",
 163     "!Foo.bar.bz",
 164     "foo.$.blah",
 165     "",
 166     "   ",
 167     "foo bar"
 168   };
 169
 170   const char *valid_unique_names[] = {
 171     ":0",
 172     ":a",
 173     ":",
 174     ":.a",
 175     ":.1",
 176     ":0.1",
 177     ":000.2222",
 178     ":.blah",
 179     ":abce.freedesktop.blah"
 180   };
 181   const char *invalid_unique_names[] = {
 182     //":-",
 183     ":!",
 184     //":0-10",
 185     ":blah.",
 186     ":blah.",
 187     ":blah..org",
 188     ":blah.org..",
 189     ":..blah.org",
 190     "",
 191     "   ",
 192     "foo bar"
 193   };
 194
 195   const char *valid_members[] = {
 196     "Hello",
 197     "Bar",
 198     "foobar",
 199     "_foobar",
 200     "foo89"
 201   };
 202
 203   const char *invalid_members[] = {
 204     "9Hello",
 205     "10",
 206     "1",
 207     "foo-bar",
 208     "blah.org",
 209     ".blah",
 210     "blah.",
 211     "Hello.",
 212     "!foo",
 213     "",
 214     "   ",
 215     "foo bar"
 216   };
 217
 218   const char *valid_signatures[] = {
 219     "",
 220     "sss",
 221     "i",
 222     "b"
 223   };
 224
 225   const char *invalid_signatures[] = {
 226     " ",
 227     "not a valid signature",
 228     "123",
 229     ".",
 230     "(",
 231     "a{(ii)i}" /* https://bugs.freedesktop.org/show_bug.cgi?id=17803 */
 232   };
 233
 234   /* Signature with reason */
 235
 236   run_validity_tests (signature_tests, _DBUS_N_ELEMENTS (signature_tests),
 237                       _dbus_validate_signature_with_reason);
 238
 239   /* Path validation */
 240   i = 0;
 241   while (i < (int) _DBUS_N_ELEMENTS (valid_paths))
 242     {
 243       _dbus_string_init_const (&str, valid_paths[i]);
 244
 245       if (!_dbus_validate_path (&str, 0,
 246                                 _dbus_string_get_length (&str)))
 247         {
 248           _dbus_warn ("Path \"%s\" should have been valid\n", valid_paths[i]);
 249           _dbus_assert_not_reached ("invalid path");
 250         }
 251
 252       ++i;
 253     }
 254
 255   i = 0;
 256   while (i < (int) _DBUS_N_ELEMENTS (invalid_paths))
 257     {
 258       _dbus_string_init_const (&str, invalid_paths[i]);
 259
 260       if (_dbus_validate_path (&str, 0,
 261                                _dbus_string_get_length (&str)))
 262         {
 263           _dbus_warn ("Path \"%s\" should have been invalid\n", invalid_paths[i]);
 264           _dbus_assert_not_reached ("valid path");
 265         }
 266
 267       ++i;
 268     }
 269
 270   /* Interface validation */
 271   i = 0;
 272   while (i < (int) _DBUS_N_ELEMENTS (valid_interfaces))
 273     {
 274       _dbus_string_init_const (&str, valid_interfaces[i]);
 275
 276       if (!_dbus_validate_interface (&str, 0,
 277                                      _dbus_string_get_length (&str)))
 278         {
 279           _dbus_warn ("Interface \"%s\" should have been valid\n", valid_interfaces[i]);
 280           _dbus_assert_not_reached ("invalid interface");
 281         }
 282
 283       ++i;
 284     }
 285
 286   i = 0;
 287   while (i < (int) _DBUS_N_ELEMENTS (invalid_interfaces))
 288     {
 289       _dbus_string_init_const (&str, invalid_interfaces[i]);
 290
 291       if (_dbus_validate_interface (&str, 0,
 292                                     _dbus_string_get_length (&str)))
 293         {
 294           _dbus_warn ("Interface \"%s\" should have been invalid\n", invalid_interfaces[i]);
 295           _dbus_assert_not_reached ("valid interface");
 296         }
 297
 298       ++i;
 299     }
 300
 301   /* Bus name validation (check that valid interfaces are valid bus names,
 302    * and invalid interfaces are invalid services except if they start with ':')
 303    */
 304   i = 0;
 305   while (i < (int) _DBUS_N_ELEMENTS (valid_interfaces))
 306     {
 307       _dbus_string_init_const (&str, valid_interfaces[i]);
 308
 309       if (!_dbus_validate_bus_name (&str, 0,
 310                                    _dbus_string_get_length (&str)))
 311         {
 312           _dbus_warn ("Bus name \"%s\" should have been valid\n", valid_interfaces[i]);
 313           _dbus_assert_not_reached ("invalid bus name");
 314         }
 315
 316       ++i;
 317     }
 318
 319   i = 0;
 320   while (i < (int) _DBUS_N_ELEMENTS (invalid_interfaces))
 321     {
 322       if (invalid_interfaces[i][0] != ':')
 323         {
 324           _dbus_string_init_const (&str, invalid_interfaces[i]);
 325
 326           if (_dbus_validate_bus_name (&str, 0,
 327                                        _dbus_string_get_length (&str)))
 328             {
 329               _dbus_warn ("Bus name \"%s\" should have been invalid\n", invalid_interfaces[i]);
 330               _dbus_assert_not_reached ("valid bus name");
 331             }
 332         }
 333
 334       ++i;
 335     }
 336
 337   /* unique name validation */
 338   i = 0;
 339   while (i < (int) _DBUS_N_ELEMENTS (valid_unique_names))
 340     {
 341       _dbus_string_init_const (&str, valid_unique_names[i]);
 342
 343       if (!_dbus_validate_bus_name (&str, 0,
 344                                     _dbus_string_get_length (&str)))
 345         {
 346           _dbus_warn ("Bus name \"%s\" should have been valid\n", valid_unique_names[i]);
 347           _dbus_assert_not_reached ("invalid unique name");
 348         }
 349
 350       ++i;
 351     }
 352
 353   i = 0;
 354   while (i < (int) _DBUS_N_ELEMENTS (invalid_unique_names))
 355     {
 356       _dbus_string_init_const (&str, invalid_unique_names[i]);
 357
 358       if (_dbus_validate_bus_name (&str, 0,
 359                                    _dbus_string_get_length (&str)))
 360         {
 361           _dbus_warn ("Bus name \"%s\" should have been invalid\n", invalid_unique_names[i]);
 362           _dbus_assert_not_reached ("valid unique name");
 363         }
 364
 365       ++i;
 366     }
 367
 368
 369   /* Error name validation (currently identical to interfaces)
 370    */
 371   i = 0;
 372   while (i < (int) _DBUS_N_ELEMENTS (valid_interfaces))
 373     {
 374       _dbus_string_init_const (&str, valid_interfaces[i]);
 375
 376       if (!_dbus_validate_error_name (&str, 0,
 377                                       _dbus_string_get_length (&str)))
 378         {
 379           _dbus_warn ("Error name \"%s\" should have been valid\n", valid_interfaces[i]);
 380           _dbus_assert_not_reached ("invalid error name");
 381         }
 382
 383       ++i;
 384     }
 385
 386   i = 0;
 387   while (i < (int) _DBUS_N_ELEMENTS (invalid_interfaces))
 388     {
 389       if (invalid_interfaces[i][0] != ':')
 390         {
 391           _dbus_string_init_const (&str, invalid_interfaces[i]);
 392
 393           if (_dbus_validate_error_name (&str, 0,
 394                                          _dbus_string_get_length (&str)))
 395             {
 396               _dbus_warn ("Error name \"%s\" should have been invalid\n", invalid_interfaces[i]);
 397               _dbus_assert_not_reached ("valid error name");
 398             }
 399         }
 400
 401       ++i;
 402     }
 403
 404   /* Member validation */
 405   i = 0;
 406   while (i < (int) _DBUS_N_ELEMENTS (valid_members))
 407     {
 408       _dbus_string_init_const (&str, valid_members[i]);
 409
 410       if (!_dbus_validate_member (&str, 0,
 411                                   _dbus_string_get_length (&str)))
 412         {
 413           _dbus_warn ("Member \"%s\" should have been valid\n", valid_members[i]);
 414           _dbus_assert_not_reached ("invalid member");
 415         }
 416
 417       ++i;
 418     }
 419
 420   i = 0;
 421   while (i < (int) _DBUS_N_ELEMENTS (invalid_members))
 422     {
 423       _dbus_string_init_const (&str, invalid_members[i]);
 424
 425       if (_dbus_validate_member (&str, 0,
 426                                  _dbus_string_get_length (&str)))
 427         {
 428           _dbus_warn ("Member \"%s\" should have been invalid\n", invalid_members[i]);
 429           _dbus_assert_not_reached ("valid member");
 430         }
 431
 432       ++i;
 433     }
 434
 435   /* Signature validation */
 436   i = 0;
 437   while (i < (int) _DBUS_N_ELEMENTS (valid_signatures))
 438     {
 439       _dbus_string_init_const (&str, valid_signatures[i]);
 440
 441       if (!_dbus_validate_signature (&str, 0,
 442                                      _dbus_string_get_length (&str)))
 443         {
 444           _dbus_warn ("Signature \"%s\" should have been valid\n", valid_signatures[i]);
 445           _dbus_assert_not_reached ("invalid signature");
 446         }
 447
 448       ++i;
 449     }
 450
 451   i = 0;
 452   while (i < (int) _DBUS_N_ELEMENTS (invalid_signatures))
 453     {
 454       _dbus_string_init_const (&str, invalid_signatures[i]);
 455
 456       if (_dbus_validate_signature (&str, 0,
 457                                     _dbus_string_get_length (&str)))
 458         {
 459           _dbus_warn ("Signature \"%s\" should have been invalid\n", invalid_signatures[i]);
 460           _dbus_assert_not_reached ("valid signature");
 461         }
 462
 463       ++i;
 464     }
 465
 466   /* Validate claimed length longer than real length */
 467   _dbus_string_init_const (&str, "abc.efg");
 468   if (_dbus_validate_bus_name (&str, 0, 8))
 469     _dbus_assert_not_reached ("validated too-long string");
 470   if (_dbus_validate_interface (&str, 0, 8))
 471     _dbus_assert_not_reached ("validated too-long string");
 472   if (_dbus_validate_error_name (&str, 0, 8))
 473     _dbus_assert_not_reached ("validated too-long string");
 474
 475   _dbus_string_init_const (&str, "abc");
 476   if (_dbus_validate_member (&str, 0, 4))
 477     _dbus_assert_not_reached ("validated too-long string");
 478
 479   _dbus_string_init_const (&str, "sss");
 480   if (_dbus_validate_signature (&str, 0, 4))
 481     _dbus_assert_not_reached ("validated too-long signature");
 482
 483   /* Validate string exceeding max name length */
 484   if (!_dbus_string_init (&str))
 485     _dbus_assert_not_reached ("no memory");
 486
 487   while (_dbus_string_get_length (&str) <= DBUS_MAXIMUM_NAME_LENGTH)
 488     if (!_dbus_string_append (&str, "abc.def"))
 489       _dbus_assert_not_reached ("no memory");
 490
 491   if (_dbus_validate_bus_name (&str, 0, _dbus_string_get_length (&str)))
 492     _dbus_assert_not_reached ("validated overmax string");
 493   if (_dbus_validate_interface (&str, 0, _dbus_string_get_length (&str)))
 494     _dbus_assert_not_reached ("validated overmax string");
 495   if (_dbus_validate_error_name (&str, 0, _dbus_string_get_length (&str)))
 496     _dbus_assert_not_reached ("validated overmax string");
 497
 498   /* overlong member */
 499   _dbus_string_set_length (&str, 0);
 500   while (_dbus_string_get_length (&str) <= DBUS_MAXIMUM_NAME_LENGTH)
 501     if (!_dbus_string_append (&str, "abc"))
 502       _dbus_assert_not_reached ("no memory");
 503
 504   if (_dbus_validate_member (&str, 0, _dbus_string_get_length (&str)))
 505     _dbus_assert_not_reached ("validated overmax string");
 506
 507   /* overlong unique name */
 508   _dbus_string_set_length (&str, 0);
 509   _dbus_string_append (&str, ":");
 510   while (_dbus_string_get_length (&str) <= DBUS_MAXIMUM_NAME_LENGTH)
 511     if (!_dbus_string_append (&str, "abc"))
 512       _dbus_assert_not_reached ("no memory");
 513
 514   if (_dbus_validate_bus_name (&str, 0, _dbus_string_get_length (&str)))
 515     _dbus_assert_not_reached ("validated overmax string");
 516
 517   _dbus_string_free (&str);
 518
 519   /* Body validation; test basic validation of valid bodies for both endian */
 520
 521   {
 522     int sequence;
 523     DBusString signature;
 524     DBusString body;
 525
 526     if (!_dbus_string_init (&signature) || !_dbus_string_init (&body))
 527       _dbus_assert_not_reached ("oom");
 528
 529     sequence = 0;
 530     while (dbus_internal_do_not_use_generate_bodies (sequence,
 531                                                      DBUS_LITTLE_ENDIAN,
 532                                                      &signature, &body))
 533       {
 534         DBusValidity validity;
 535
 536         validity = _dbus_validate_body_with_reason (&signature, 0,
 537                                                     DBUS_LITTLE_ENDIAN,
 538                                                     NULL, &body, 0,
 539                                                     _dbus_string_get_length (&body));
 540         if (validity != DBUS_VALID)
 541           {
 542             _dbus_warn ("invalid code %d expected valid on sequence %d little endian\n",
 543                         validity, sequence);
 544             _dbus_verbose_bytes_of_string (&signature, 0, _dbus_string_get_length (&signature));
 545             _dbus_verbose_bytes_of_string (&body, 0, _dbus_string_get_length (&body));
 546             _dbus_assert_not_reached ("test failed");
 547           }
 548
 549         _dbus_string_set_length (&signature, 0);
 550         _dbus_string_set_length (&body, 0);
 551         ++sequence;
 552       }
 553
 554     sequence = 0;
 555     while (dbus_internal_do_not_use_generate_bodies (sequence,
 556                                                      DBUS_BIG_ENDIAN,
 557                                                      &signature, &body))
 558       {
 559         DBusValidity validity;
 560
 561         validity = _dbus_validate_body_with_reason (&signature, 0,
 562                                                     DBUS_BIG_ENDIAN,
 563                                                     NULL, &body, 0,
 564                                                     _dbus_string_get_length (&body));
 565         if (validity != DBUS_VALID)
 566           {
 567             _dbus_warn ("invalid code %d expected valid on sequence %d big endian\n",
 568                         validity, sequence);
 569             _dbus_verbose_bytes_of_string (&signature, 0, _dbus_string_get_length (&signature));
 570             _dbus_verbose_bytes_of_string (&body, 0, _dbus_string_get_length (&body));
 571             _dbus_assert_not_reached ("test failed");
 572           }
 573
 574         _dbus_string_set_length (&signature, 0);
 575         _dbus_string_set_length (&body, 0);
 576         ++sequence;
 577       }
 578
 579     _dbus_string_free (&signature);
 580     _dbus_string_free (&body);
 581   }
 582
 583   return TRUE;
 584 }
 585
 586 #endif /* !DOXYGEN_SHOULD_SKIP_THIS */
 587
 588 #endif /* DBUS_ENABLE_EMBEDDED_TESTS */