bus/signals.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* signals.c  Bus signal connection implementation
   3  *
   4  * Copyright (C) 2003, 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 #include "signals.h"
  26 #include "services.h"
  27 #include "utils.h"
  28 #include <dbus/dbus-marshal-validate.h>
  29
  30 struct BusMatchRule
  31 {
  32   int refcount;       /**< reference count */
  33
  34   DBusConnection *matches_go_to; /**< Owner of the rule */
  35
  36   unsigned int flags; /**< BusMatchFlags */
  37
  38   int   message_type;
  39   char *interface;
  40   char *member;
  41   char *sender;
  42   char *destination;
  43   char *path;
  44
  45   unsigned int *arg_lens;
  46   char **args;
  47   int args_len;
  48 };
  49
  50 #define BUS_MATCH_ARG_IS_PATH  0x8000000u
  51
  52 BusMatchRule*
  53 bus_match_rule_new (DBusConnection *matches_go_to)
  54 {
  55   BusMatchRule *rule;
  56
  57   rule = dbus_new0 (BusMatchRule, 1);
  58   if (rule == NULL)
  59     return NULL;
  60
  61   rule->refcount = 1;
  62   rule->matches_go_to = matches_go_to;
  63
  64 #ifndef DBUS_BUILD_TESTS
  65   _dbus_assert (rule->matches_go_to != NULL);
  66 #endif
  67
  68   return rule;
  69 }
  70
  71 BusMatchRule *
  72 bus_match_rule_ref (BusMatchRule *rule)
  73 {
  74   _dbus_assert (rule->refcount > 0);
  75
  76   rule->refcount += 1;
  77
  78   return rule;
  79 }
  80
  81 void
  82 bus_match_rule_unref (BusMatchRule *rule)
  83 {
  84   _dbus_assert (rule->refcount > 0);
  85
  86   rule->refcount -= 1;
  87   if (rule->refcount == 0)
  88     {
  89       dbus_free (rule->interface);
  90       dbus_free (rule->member);
  91       dbus_free (rule->sender);
  92       dbus_free (rule->destination);
  93       dbus_free (rule->path);
  94       dbus_free (rule->arg_lens);
  95
  96       /* can't use dbus_free_string_array() since there
  97        * are embedded NULL
  98        */
  99       if (rule->args)
 100         {
 101           int i;
 102
 103           i = 0;
 104           while (i < rule->args_len)
 105             {
 106               if (rule->args[i])
 107                 dbus_free (rule->args[i]);
 108               ++i;
 109             }
 110
 111           dbus_free (rule->args);
 112         }
 113
 114       dbus_free (rule);
 115     }
 116 }
 117
 118 #ifdef DBUS_ENABLE_VERBOSE_MODE
 119 /* Note this function does not do escaping, so it's only
 120  * good for debug spew at the moment
 121  */
 122 static char*
 123 match_rule_to_string (BusMatchRule *rule)
 124 {
 125   DBusString str;
 126   char *ret;
 127
 128   if (!_dbus_string_init (&str))
 129     {
 130       char *s;
 131       while ((s = _dbus_strdup ("nomem")) == NULL)
 132         ; /* only OK for debug spew... */
 133       return s;
 134     }
 135
 136   if (rule->flags & BUS_MATCH_MESSAGE_TYPE)
 137     {
 138       /* FIXME make type readable */
 139       if (!_dbus_string_append_printf (&str, "type='%d'", rule->message_type))
 140         goto nomem;
 141     }
 142
 143   if (rule->flags & BUS_MATCH_INTERFACE)
 144     {
 145       if (_dbus_string_get_length (&str) > 0)
 146         {
 147           if (!_dbus_string_append (&str, ","))
 148             goto nomem;
 149         }
 150
 151       if (!_dbus_string_append_printf (&str, "interface='%s'", rule->interface))
 152         goto nomem;
 153     }
 154
 155   if (rule->flags & BUS_MATCH_MEMBER)
 156     {
 157       if (_dbus_string_get_length (&str) > 0)
 158         {
 159           if (!_dbus_string_append (&str, ","))
 160             goto nomem;
 161         }
 162
 163       if (!_dbus_string_append_printf (&str, "member='%s'", rule->member))
 164         goto nomem;
 165     }
 166
 167   if (rule->flags & BUS_MATCH_PATH)
 168     {
 169       if (_dbus_string_get_length (&str) > 0)
 170         {
 171           if (!_dbus_string_append (&str, ","))
 172             goto nomem;
 173         }
 174
 175       if (!_dbus_string_append_printf (&str, "path='%s'", rule->path))
 176         goto nomem;
 177     }
 178
 179   if (rule->flags & BUS_MATCH_SENDER)
 180     {
 181       if (_dbus_string_get_length (&str) > 0)
 182         {
 183           if (!_dbus_string_append (&str, ","))
 184             goto nomem;
 185         }
 186
 187       if (!_dbus_string_append_printf (&str, "sender='%s'", rule->sender))
 188         goto nomem;
 189     }
 190
 191   if (rule->flags & BUS_MATCH_DESTINATION)
 192     {
 193       if (_dbus_string_get_length (&str) > 0)
 194         {
 195           if (!_dbus_string_append (&str, ","))
 196             goto nomem;
 197         }
 198
 199       if (!_dbus_string_append_printf (&str, "destination='%s'", rule->destination))
 200         goto nomem;
 201     }
 202
 203   if (rule->flags & BUS_MATCH_ARGS)
 204     {
 205       int i;
 206
 207       _dbus_assert (rule->args != NULL);
 208
 209       i = 0;
 210       while (i < rule->args_len)
 211         {
 212           if (rule->args[i] != NULL)
 213             {
 214               dbus_bool_t is_path;
 215
 216               if (_dbus_string_get_length (&str) > 0)
 217                 {
 218                   if (!_dbus_string_append (&str, ","))
 219                     goto nomem;
 220                 }
 221
 222               is_path = (rule->arg_lens[i] & BUS_MATCH_ARG_IS_PATH) != 0;
 223
 224               if (!_dbus_string_append_printf (&str,
 225                                                "arg%d%s='%s'",
 226                                                i, is_path ? "path" : "",
 227                                                rule->args[i]))
 228                 goto nomem;
 229             }
 230
 231           ++i;
 232         }
 233     }
 234
 235   if (!_dbus_string_steal_data (&str, &ret))
 236     goto nomem;
 237
 238   _dbus_string_free (&str);
 239   return ret;
 240
 241  nomem:
 242   _dbus_string_free (&str);
 243   {
 244     char *s;
 245     while ((s = _dbus_strdup ("nomem")) == NULL)
 246       ;  /* only OK for debug spew... */
 247     return s;
 248   }
 249 }
 250 #endif /* DBUS_ENABLE_VERBOSE_MODE */
 251
 252 dbus_bool_t
 253 bus_match_rule_set_message_type (BusMatchRule *rule,
 254                                  int           type)
 255 {
 256   rule->flags |= BUS_MATCH_MESSAGE_TYPE;
 257
 258   rule->message_type = type;
 259
 260   return TRUE;
 261 }
 262
 263 dbus_bool_t
 264 bus_match_rule_set_interface (BusMatchRule *rule,
 265                               const char   *interface)
 266 {
 267   char *new;
 268
 269   _dbus_assert (interface != NULL);
 270
 271   new = _dbus_strdup (interface);
 272   if (new == NULL)
 273     return FALSE;
 274
 275   rule->flags |= BUS_MATCH_INTERFACE;
 276   dbus_free (rule->interface);
 277   rule->interface = new;
 278
 279   return TRUE;
 280 }
 281
 282 dbus_bool_t
 283 bus_match_rule_set_member (BusMatchRule *rule,
 284                            const char   *member)
 285 {
 286   char *new;
 287
 288   _dbus_assert (member != NULL);
 289
 290   new = _dbus_strdup (member);
 291   if (new == NULL)
 292     return FALSE;
 293
 294   rule->flags |= BUS_MATCH_MEMBER;
 295   dbus_free (rule->member);
 296   rule->member = new;
 297
 298   return TRUE;
 299 }
 300
 301 dbus_bool_t
 302 bus_match_rule_set_sender (BusMatchRule *rule,
 303                            const char   *sender)
 304 {
 305   char *new;
 306
 307   _dbus_assert (sender != NULL);
 308
 309   new = _dbus_strdup (sender);
 310   if (new == NULL)
 311     return FALSE;
 312
 313   rule->flags |= BUS_MATCH_SENDER;
 314   dbus_free (rule->sender);
 315   rule->sender = new;
 316
 317   return TRUE;
 318 }
 319
 320 dbus_bool_t
 321 bus_match_rule_set_destination (BusMatchRule *rule,
 322                                 const char   *destination)
 323 {
 324   char *new;
 325
 326   _dbus_assert (destination != NULL);
 327
 328   new = _dbus_strdup (destination);
 329   if (new == NULL)
 330     return FALSE;
 331
 332   rule->flags |= BUS_MATCH_DESTINATION;
 333   dbus_free (rule->destination);
 334   rule->destination = new;
 335
 336   return TRUE;
 337 }
 338
 339 dbus_bool_t
 340 bus_match_rule_set_path (BusMatchRule *rule,
 341                          const char   *path)
 342 {
 343   char *new;
 344
 345   _dbus_assert (path != NULL);
 346
 347   new = _dbus_strdup (path);
 348   if (new == NULL)
 349     return FALSE;
 350
 351   rule->flags |= BUS_MATCH_PATH;
 352   dbus_free (rule->path);
 353   rule->path = new;
 354
 355   return TRUE;
 356 }
 357
 358 dbus_bool_t
 359 bus_match_rule_set_arg (BusMatchRule     *rule,
 360                         int                arg,
 361                         const DBusString *value,
 362                         dbus_bool_t       is_path)
 363 {
 364   int length;
 365   char *new;
 366
 367   _dbus_assert (value != NULL);
 368
 369   /* args_len is the number of args not including null termination
 370    * in the char**
 371    */
 372   if (arg >= rule->args_len)
 373     {
 374       unsigned int *new_arg_lens;
 375       char **new_args;
 376       int new_args_len;
 377       int i;
 378
 379       new_args_len = arg + 1;
 380
 381       /* add another + 1 here for null termination */
 382       new_args = dbus_realloc (rule->args,
 383                                sizeof (char *) * (new_args_len + 1));
 384       if (new_args == NULL)
 385         return FALSE;
 386
 387       /* NULL the new slots */
 388       i = rule->args_len;
 389       while (i <= new_args_len) /* <= for null termination */
 390         {
 391           new_args[i] = NULL;
 392           ++i;
 393         }
 394
 395       rule->args = new_args;
 396
 397       /* and now add to the lengths */
 398       new_arg_lens = dbus_realloc (rule->arg_lens,
 399                                    sizeof (int) * (new_args_len + 1));
 400
 401       if (new_arg_lens == NULL)
 402         return FALSE;
 403
 404       /* zero the new slots */
 405       i = rule->args_len;
 406       while (i <= new_args_len) /* <= for null termination */
 407         {
 408           new_arg_lens[i] = 0;
 409           ++i;
 410         }
 411
 412       rule->arg_lens = new_arg_lens;
 413       rule->args_len = new_args_len;
 414     }
 415
 416   length = _dbus_string_get_length (value);
 417   if (!_dbus_string_copy_data (value, &new))
 418     return FALSE;
 419
 420   rule->flags |= BUS_MATCH_ARGS;
 421
 422   dbus_free (rule->args[arg]);
 423   rule->arg_lens[arg] = length;
 424   rule->args[arg] = new;
 425
 426   if (is_path)
 427     rule->arg_lens[arg] |= BUS_MATCH_ARG_IS_PATH;
 428
 429   /* NULL termination didn't get busted */
 430   _dbus_assert (rule->args[rule->args_len] == NULL);
 431   _dbus_assert (rule->arg_lens[rule->args_len] == 0);
 432
 433   return TRUE;
 434 }
 435
 436 #define ISWHITE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r'))
 437
 438 static dbus_bool_t
 439 find_key (const DBusString *str,
 440           int               start,
 441           DBusString       *key,
 442           int              *value_pos,
 443           DBusError        *error)
 444 {
 445   const char *p;
 446   const char *s;
 447   const char *key_start;
 448   const char *key_end;
 449
 450   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 451
 452   s = _dbus_string_get_const_data (str);
 453
 454   p = s + start;
 455
 456   while (*p && ISWHITE (*p))
 457     ++p;
 458
 459   key_start = p;
 460
 461   while (*p && *p != '=' && !ISWHITE (*p))
 462     ++p;
 463
 464   key_end = p;
 465
 466   while (*p && ISWHITE (*p))
 467     ++p;
 468
 469   if (key_start == key_end)
 470     {
 471       /* Empty match rules or trailing whitespace are OK */
 472       *value_pos = p - s;
 473       return TRUE;
 474     }
 475
 476   if (*p != '=')
 477     {
 478       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 479                       "Match rule has a key with no subsequent '=' character");
 480       return FALSE;
 481     }
 482   ++p;
 483
 484   if (!_dbus_string_append_len (key, key_start, key_end - key_start))
 485     {
 486       BUS_SET_OOM (error);
 487       return FALSE;
 488     }
 489
 490   *value_pos = p - s;
 491
 492   return TRUE;
 493 }
 494
 495 static dbus_bool_t
 496 find_value (const DBusString *str,
 497             int               start,
 498             const char       *key,
 499             DBusString       *value,
 500             int              *value_end,
 501             DBusError        *error)
 502 {
 503   const char *p;
 504   const char *s;
 505   char quote_char;
 506   int orig_len;
 507
 508   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 509
 510   orig_len = _dbus_string_get_length (value);
 511
 512   s = _dbus_string_get_const_data (str);
 513
 514   p = s + start;
 515
 516   quote_char = '\0';
 517
 518   while (*p)
 519     {
 520       if (quote_char == '\0')
 521         {
 522           switch (*p)
 523             {
 524             case '\0':
 525               goto done;
 526
 527             case '\'':
 528               quote_char = '\'';
 529               goto next;
 530
 531             case ',':
 532               ++p;
 533               goto done;
 534
 535             case '\\':
 536               quote_char = '\\';
 537               goto next;
 538
 539             default:
 540               if (!_dbus_string_append_byte (value, *p))
 541                 {
 542                   BUS_SET_OOM (error);
 543                   goto failed;
 544                 }
 545             }
 546         }
 547       else if (quote_char == '\\')
 548         {
 549           /* \ only counts as an escape if escaping a quote mark */
 550           if (*p != '\'')
 551             {
 552               if (!_dbus_string_append_byte (value, '\\'))
 553                 {
 554                   BUS_SET_OOM (error);
 555                   goto failed;
 556                 }
 557             }
 558
 559           if (!_dbus_string_append_byte (value, *p))
 560             {
 561               BUS_SET_OOM (error);
 562               goto failed;
 563             }
 564
 565           quote_char = '\0';
 566         }
 567       else
 568         {
 569           _dbus_assert (quote_char == '\'');
 570
 571           if (*p == '\'')
 572             {
 573               quote_char = '\0';
 574             }
 575           else
 576             {
 577               if (!_dbus_string_append_byte (value, *p))
 578                 {
 579                   BUS_SET_OOM (error);
 580                   goto failed;
 581                 }
 582             }
 583         }
 584
 585     next:
 586       ++p;
 587     }
 588
 589  done:
 590
 591   if (quote_char == '\\')
 592     {
 593       if (!_dbus_string_append_byte (value, '\\'))
 594         {
 595           BUS_SET_OOM (error);
 596           goto failed;
 597         }
 598     }
 599   else if (quote_char == '\'')
 600     {
 601       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 602                       "Unbalanced quotation marks in match rule");
 603       goto failed;
 604     }
 605   else
 606     _dbus_assert (quote_char == '\0');
 607
 608   /* Zero-length values are allowed */
 609
 610   *value_end = p - s;
 611
 612   return TRUE;
 613
 614  failed:
 615   _DBUS_ASSERT_ERROR_IS_SET (error);
 616   _dbus_string_set_length (value, orig_len);
 617   return FALSE;
 618 }
 619
 620 /* duplicates aren't allowed so the real legitimate max is only 6 or
 621  * so. Leaving extra so we don't have to bother to update it.
 622  * FIXME this is sort of busted now with arg matching, but we let
 623  * you match on up to 10 args for now
 624  */
 625 #define MAX_RULE_TOKENS 16
 626
 627 /* this is slightly too high level to be termed a "token"
 628  * but let's not be pedantic.
 629  */
 630 typedef struct
 631 {
 632   char *key;
 633   char *value;
 634 } RuleToken;
 635
 636 static dbus_bool_t
 637 tokenize_rule (const DBusString *rule_text,
 638                RuleToken         tokens[MAX_RULE_TOKENS],
 639                DBusError        *error)
 640 {
 641   int i;
 642   int pos;
 643   DBusString key;
 644   DBusString value;
 645   dbus_bool_t retval;
 646
 647   retval = FALSE;
 648
 649   if (!_dbus_string_init (&key))
 650     {
 651       BUS_SET_OOM (error);
 652       return FALSE;
 653     }
 654
 655   if (!_dbus_string_init (&value))
 656     {
 657       _dbus_string_free (&key);
 658       BUS_SET_OOM (error);
 659       return FALSE;
 660     }
 661
 662   i = 0;
 663   pos = 0;
 664   while (i < MAX_RULE_TOKENS &&
 665          pos < _dbus_string_get_length (rule_text))
 666     {
 667       _dbus_assert (tokens[i].key == NULL);
 668       _dbus_assert (tokens[i].value == NULL);
 669
 670       if (!find_key (rule_text, pos, &key, &pos, error))
 671         goto out;
 672
 673       if (_dbus_string_get_length (&key) == 0)
 674         goto next;
 675
 676       if (!_dbus_string_steal_data (&key, &tokens[i].key))
 677         {
 678           BUS_SET_OOM (error);
 679           goto out;
 680         }
 681
 682       if (!find_value (rule_text, pos, tokens[i].key, &value, &pos, error))
 683         goto out;
 684
 685       if (!_dbus_string_steal_data (&value, &tokens[i].value))
 686         {
 687           BUS_SET_OOM (error);
 688           goto out;
 689         }
 690
 691     next:
 692       ++i;
 693     }
 694
 695   retval = TRUE;
 696
 697  out:
 698   if (!retval)
 699     {
 700       i = 0;
 701       while (tokens[i].key || tokens[i].value)
 702         {
 703           dbus_free (tokens[i].key);
 704           dbus_free (tokens[i].value);
 705           tokens[i].key = NULL;
 706           tokens[i].value = NULL;
 707           ++i;
 708         }
 709     }
 710
 711   _dbus_string_free (&key);
 712   _dbus_string_free (&value);
 713
 714   return retval;
 715 }
 716
 717 static dbus_bool_t
 718 bus_match_rule_parse_arg_match (BusMatchRule     *rule,
 719                                 const char       *key,
 720                                 const DBusString *value,
 721                                 DBusError        *error)
 722 {
 723   dbus_bool_t is_path;
 724   DBusString key_str;
 725   unsigned long arg;
 726   int length;
 727   int end;
 728
 729   /* For now, arg0='foo' always implies that 'foo' is a
 730    * DBUS_TYPE_STRING. Someday we could add an arg0type='int32' thing
 731    * if we wanted, which would specify another type, in which case
 732    * arg0='5' would have the 5 parsed as an int rather than string.
 733    */
 734
 735   /* First we need to parse arg0 = 0, arg27 = 27 */
 736
 737   _dbus_string_init_const (&key_str, key);
 738   length = _dbus_string_get_length (&key_str);
 739
 740   if (_dbus_string_get_length (&key_str) < 4)
 741     {
 742       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 743                       "Key '%s' in match rule starts with 'arg' but lacks an arg number. Should be 'arg0' or 'arg7' for example.\n", key);
 744       goto failed;
 745     }
 746
 747   if (!_dbus_string_parse_uint (&key_str, 3, &arg, &end))
 748     {
 749       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 750                       "Key '%s' in match rule starts with 'arg' but could not parse arg number. Should be 'arg0' or 'arg7' for example.\n", key);
 751       goto failed;
 752     }
 753
 754   if (end != length &&
 755       ((end + 4) != length ||
 756        !_dbus_string_ends_with_c_str (&key_str, "path")))
 757     {
 758       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 759                       "Key '%s' in match rule contains junk after argument number. Only 'path' is optionally valid ('arg0path' for example).\n", key);
 760       goto failed;
 761     }
 762
 763   is_path = end != length;
 764
 765   /* If we didn't check this we could allocate a huge amount of RAM */
 766   if (arg > DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER)
 767     {
 768       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 769                       "Key '%s' in match rule has arg number %lu but the maximum is %d.\n", key, (unsigned long) arg, DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER);
 770       goto failed;
 771     }
 772
 773   if ((rule->flags & BUS_MATCH_ARGS) &&
 774       rule->args_len > (int) arg &&
 775       rule->args[arg] != NULL)
 776     {
 777       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 778                       "Argument %d matched more than once in match rule\n", key);
 779       goto failed;
 780     }
 781
 782   if (!bus_match_rule_set_arg (rule, arg, value, is_path))
 783     {
 784       BUS_SET_OOM (error);
 785       goto failed;
 786     }
 787
 788   return TRUE;
 789
 790  failed:
 791   _DBUS_ASSERT_ERROR_IS_SET (error);
 792   return FALSE;
 793 }
 794
 795 /*
 796  * The format is comma-separated with strings quoted with single quotes
 797  * as for the shell (to escape a literal single quote, use '\'').
 798  *
 799  * type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='Foo',
 800  * path='/bar/foo',destination=':452345.34'
 801  *
 802  */
 803 BusMatchRule*
 804 bus_match_rule_parse (DBusConnection   *matches_go_to,
 805                       const DBusString *rule_text,
 806                       DBusError        *error)
 807 {
 808   BusMatchRule *rule;
 809   RuleToken tokens[MAX_RULE_TOKENS+1]; /* NULL termination + 1 */
 810   int i;
 811
 812   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 813
 814   if (_dbus_string_get_length (rule_text) > DBUS_MAXIMUM_MATCH_RULE_LENGTH)
 815     {
 816       dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,
 817                       "Match rule text is %d bytes, maximum is %d",
 818                       _dbus_string_get_length (rule_text),
 819                       DBUS_MAXIMUM_MATCH_RULE_LENGTH);
 820       return NULL;
 821     }
 822
 823   memset (tokens, '\0', sizeof (tokens));
 824
 825   rule = bus_match_rule_new (matches_go_to);
 826   if (rule == NULL)
 827     {
 828       BUS_SET_OOM (error);
 829       goto failed;
 830     }
 831
 832   if (!tokenize_rule (rule_text, tokens, error))
 833     goto failed;
 834
 835   i = 0;
 836   while (tokens[i].key != NULL)
 837     {
 838       DBusString tmp_str;
 839       int len;
 840       const char *key = tokens[i].key;
 841       const char *value = tokens[i].value;
 842
 843       _dbus_string_init_const (&tmp_str, value);
 844       len = _dbus_string_get_length (&tmp_str);
 845
 846       if (strcmp (key, "type") == 0)
 847         {
 848           int t;
 849
 850           if (rule->flags & BUS_MATCH_MESSAGE_TYPE)
 851             {
 852               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 853                               "Key %s specified twice in match rule\n", key);
 854               goto failed;
 855             }
 856
 857           t = dbus_message_type_from_string (value);
 858
 859           if (t == DBUS_MESSAGE_TYPE_INVALID)
 860             {
 861               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 862                               "Invalid message type (%s) in match rule\n", value);
 863               goto failed;
 864             }
 865
 866           if (!bus_match_rule_set_message_type (rule, t))
 867             {
 868               BUS_SET_OOM (error);
 869               goto failed;
 870             }
 871         }
 872       else if (strcmp (key, "sender") == 0)
 873         {
 874           if (rule->flags & BUS_MATCH_SENDER)
 875             {
 876               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 877                               "Key %s specified twice in match rule\n", key);
 878               goto failed;
 879             }
 880
 881           if (!_dbus_validate_bus_name (&tmp_str, 0, len))
 882             {
 883               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 884                               "Sender name '%s' is invalid\n", value);
 885               goto failed;
 886             }
 887
 888           if (!bus_match_rule_set_sender (rule, value))
 889             {
 890               BUS_SET_OOM (error);
 891               goto failed;
 892             }
 893         }
 894       else if (strcmp (key, "interface") == 0)
 895         {
 896           if (rule->flags & BUS_MATCH_INTERFACE)
 897             {
 898               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 899                               "Key %s specified twice in match rule\n", key);
 900               goto failed;
 901             }
 902
 903           if (!_dbus_validate_interface (&tmp_str, 0, len))
 904             {
 905               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 906                               "Interface name '%s' is invalid\n", value);
 907               goto failed;
 908             }
 909
 910           if (!bus_match_rule_set_interface (rule, value))
 911             {
 912               BUS_SET_OOM (error);
 913               goto failed;
 914             }
 915         }
 916       else if (strcmp (key, "member") == 0)
 917         {
 918           if (rule->flags & BUS_MATCH_MEMBER)
 919             {
 920               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 921                               "Key %s specified twice in match rule\n", key);
 922               goto failed;
 923             }
 924
 925           if (!_dbus_validate_member (&tmp_str, 0, len))
 926             {
 927               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 928                               "Member name '%s' is invalid\n", value);
 929               goto failed;
 930             }
 931
 932           if (!bus_match_rule_set_member (rule, value))
 933             {
 934               BUS_SET_OOM (error);
 935               goto failed;
 936             }
 937         }
 938       else if (strcmp (key, "path") == 0)
 939         {
 940           if (rule->flags & BUS_MATCH_PATH)
 941             {
 942               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 943                               "Key %s specified twice in match rule\n", key);
 944               goto failed;
 945             }
 946
 947           if (!_dbus_validate_path (&tmp_str, 0, len))
 948             {
 949               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 950                               "Path '%s' is invalid\n", value);
 951               goto failed;
 952             }
 953
 954           if (!bus_match_rule_set_path (rule, value))
 955             {
 956               BUS_SET_OOM (error);
 957               goto failed;
 958             }
 959         }
 960       else if (strcmp (key, "destination") == 0)
 961         {
 962           if (rule->flags & BUS_MATCH_DESTINATION)
 963             {
 964               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 965                               "Key %s specified twice in match rule\n", key);
 966               goto failed;
 967             }
 968
 969           if (!_dbus_validate_bus_name (&tmp_str, 0, len))
 970             {
 971               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 972                               "Destination name '%s' is invalid\n", value);
 973               goto failed;
 974             }
 975
 976           if (!bus_match_rule_set_destination (rule, value))
 977             {
 978               BUS_SET_OOM (error);
 979               goto failed;
 980             }
 981         }
 982       else if (strncmp (key, "arg", 3) == 0)
 983         {
 984           if (!bus_match_rule_parse_arg_match (rule, key, &tmp_str, error))
 985             goto failed;
 986         }
 987       else
 988         {
 989           dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
 990                           "Unknown key \"%s\" in match rule",
 991                           key);
 992           goto failed;
 993         }
 994
 995       ++i;
 996     }
 997
 998
 999   goto out;
1000
1001  failed:
1002   _DBUS_ASSERT_ERROR_IS_SET (error);
1003   if (rule)
1004     {
1005       bus_match_rule_unref (rule);
1006       rule = NULL;
1007     }
1008
1009  out:
1010
1011   i = 0;
1012   while (tokens[i].key || tokens[i].value)
1013     {
1014       _dbus_assert (i < MAX_RULE_TOKENS);
1015       dbus_free (tokens[i].key);
1016       dbus_free (tokens[i].value);
1017       ++i;
1018     }
1019
1020   return rule;
1021 }
1022
1023 typedef struct RulePool RulePool;
1024 struct RulePool
1025 {
1026   /* Maps non-NULL interface names to non-NULL (DBusList **)s */
1027   DBusHashTable *rules_by_iface;
1028
1029   /* List of BusMatchRules which don't specify an interface */
1030   DBusList *rules_without_iface;
1031 };
1032
1033 struct BusMatchmaker
1034 {
1035   int refcount;
1036
1037   /* Pools of rules, grouped by the type of message they match. 0
1038    * (DBUS_MESSAGE_TYPE_INVALID) represents rules that do not specify a message
1039    * type.
1040    */
1041   RulePool rules_by_type[DBUS_NUM_MESSAGE_TYPES];
1042 };
1043
1044 static void
1045 rule_list_free (DBusList **rules)
1046 {
1047   while (*rules != NULL)
1048     {
1049       BusMatchRule *rule;
1050
1051       rule = (*rules)->data;
1052       bus_match_rule_unref (rule);
1053       _dbus_list_remove_link (rules, *rules);
1054     }
1055 }
1056
1057 static void
1058 rule_list_ptr_free (DBusList **list)
1059 {
1060   /* We have to cope with NULL because the hash table frees the "existing"
1061    * value (which is NULL) when creating a new table entry...
1062    */
1063   if (list != NULL)
1064     {
1065       rule_list_free (list);
1066       dbus_free (list);
1067     }
1068 }
1069
1070 BusMatchmaker*
1071 bus_matchmaker_new (void)
1072 {
1073   BusMatchmaker *matchmaker;
1074   int i;
1075
1076   matchmaker = dbus_new0 (BusMatchmaker, 1);
1077   if (matchmaker == NULL)
1078     return NULL;
1079
1080   matchmaker->refcount = 1;
1081
1082   for (i = DBUS_MESSAGE_TYPE_INVALID; i < DBUS_NUM_MESSAGE_TYPES; i++)
1083     {
1084       RulePool *p = matchmaker->rules_by_type + i;
1085
1086       p->rules_by_iface = _dbus_hash_table_new (DBUS_HASH_STRING,
1087           dbus_free, (DBusFreeFunction) rule_list_ptr_free);
1088
1089       if (p->rules_by_iface == NULL)
1090         goto nomem;
1091     }
1092
1093   return matchmaker;
1094
1095  nomem:
1096   for (i = DBUS_MESSAGE_TYPE_INVALID; i < DBUS_NUM_MESSAGE_TYPES; i++)
1097     {
1098       RulePool *p = matchmaker->rules_by_type + i;
1099
1100       if (p->rules_by_iface == NULL)
1101         break;
1102       else
1103         _dbus_hash_table_unref (p->rules_by_iface);
1104     }
1105
1106   return NULL;
1107 }
1108
1109 static DBusList **
1110 bus_matchmaker_get_rules (BusMatchmaker *matchmaker,
1111                           int            message_type,
1112                           const char    *interface,
1113                           dbus_bool_t    create)
1114 {
1115   RulePool *p;
1116
1117   _dbus_assert (message_type >= 0);
1118   _dbus_assert (message_type < DBUS_NUM_MESSAGE_TYPES);
1119
1120   _dbus_verbose ("Looking up rules for message_type %d, interface %s\n",
1121                  message_type,
1122                  interface != NULL ? interface : "<null>");
1123
1124   p = matchmaker->rules_by_type + message_type;
1125
1126   if (interface == NULL)
1127     {
1128       return &p->rules_without_iface;
1129     }
1130   else
1131     {
1132       DBusList **list;
1133
1134       list = _dbus_hash_table_lookup_string (p->rules_by_iface, interface);
1135
1136       if (list == NULL && create)
1137         {
1138           char *dupped_interface;
1139
1140           list = dbus_new0 (DBusList *, 1);
1141           if (list == NULL)
1142             return NULL;
1143
1144           dupped_interface = _dbus_strdup (interface);
1145           if (dupped_interface == NULL)
1146             {
1147               dbus_free (list);
1148               return NULL;
1149             }
1150
1151           _dbus_verbose ("Adding list for type %d, iface %s\n", message_type,
1152                          interface);
1153
1154           if (!_dbus_hash_table_insert_string (p->rules_by_iface,
1155                                                dupped_interface, list))
1156             {
1157               dbus_free (list);
1158               dbus_free (dupped_interface);
1159               return NULL;
1160             }
1161         }
1162
1163       return list;
1164     }
1165 }
1166
1167 static void
1168 bus_matchmaker_gc_rules (BusMatchmaker *matchmaker,
1169                          int            message_type,
1170                          const char    *interface,
1171                          DBusList     **rules)
1172 {
1173   RulePool *p;
1174
1175   if (interface == NULL)
1176     return;
1177
1178   if (*rules != NULL)
1179     return;
1180
1181   _dbus_verbose ("GCing HT entry for message_type %u, interface %s\n",
1182                  message_type, interface);
1183
1184   p = matchmaker->rules_by_type + message_type;
1185
1186   _dbus_assert (_dbus_hash_table_lookup_string (p->rules_by_iface, interface)
1187       == rules);
1188
1189   _dbus_hash_table_remove_string (p->rules_by_iface, interface);
1190 }
1191
1192 BusMatchmaker *
1193 bus_matchmaker_ref (BusMatchmaker *matchmaker)
1194 {
1195   _dbus_assert (matchmaker->refcount > 0);
1196
1197   matchmaker->refcount += 1;
1198
1199   return matchmaker;
1200 }
1201
1202 void
1203 bus_matchmaker_unref (BusMatchmaker *matchmaker)
1204 {
1205   _dbus_assert (matchmaker->refcount > 0);
1206
1207   matchmaker->refcount -= 1;
1208   if (matchmaker->refcount == 0)
1209     {
1210       int i;
1211
1212       for (i = DBUS_MESSAGE_TYPE_INVALID; i < DBUS_NUM_MESSAGE_TYPES; i++)
1213         {
1214           RulePool *p = matchmaker->rules_by_type + i;
1215
1216           _dbus_hash_table_unref (p->rules_by_iface);
1217           rule_list_free (&p->rules_without_iface);
1218         }
1219
1220       dbus_free (matchmaker);
1221     }
1222 }
1223
1224 /* The rule can't be modified after it's added. */
1225 dbus_bool_t
1226 bus_matchmaker_add_rule (BusMatchmaker   *matchmaker,
1227                          BusMatchRule    *rule)
1228 {
1229   DBusList **rules;
1230
1231   _dbus_assert (bus_connection_is_active (rule->matches_go_to));
1232
1233   _dbus_verbose ("Adding rule with message_type %d, interface %s\n",
1234                  rule->message_type,
1235                  rule->interface != NULL ? rule->interface : "<null>");
1236
1237   rules = bus_matchmaker_get_rules (matchmaker, rule->message_type,
1238                                     rule->interface, TRUE);
1239
1240   if (rules == NULL)
1241     return FALSE;
1242
1243   if (!_dbus_list_append (rules, rule))
1244     return FALSE;
1245
1246   if (!bus_connection_add_match_rule (rule->matches_go_to, rule))
1247     {
1248       _dbus_list_remove_last (rules, rule);
1249       bus_matchmaker_gc_rules (matchmaker, rule->message_type,
1250                                rule->interface, rules);
1251       return FALSE;
1252     }
1253
1254   bus_match_rule_ref (rule);
1255
1256 #ifdef DBUS_ENABLE_VERBOSE_MODE
1257   {
1258     char *s = match_rule_to_string (rule);
1259
1260     _dbus_verbose ("Added match rule %s to connection %p\n",
1261                    s, rule->matches_go_to);
1262     dbus_free (s);
1263   }
1264 #endif
1265
1266   return TRUE;
1267 }
1268
1269 static dbus_bool_t
1270 match_rule_equal (BusMatchRule *a,
1271                   BusMatchRule *b)
1272 {
1273   if (a->flags != b->flags)
1274     return FALSE;
1275
1276   if (a->matches_go_to != b->matches_go_to)
1277     return FALSE;
1278
1279   if ((a->flags & BUS_MATCH_MESSAGE_TYPE) &&
1280       a->message_type != b->message_type)
1281     return FALSE;
1282
1283   if ((a->flags & BUS_MATCH_MEMBER) &&
1284       strcmp (a->member, b->member) != 0)
1285     return FALSE;
1286
1287   if ((a->flags & BUS_MATCH_PATH) &&
1288       strcmp (a->path, b->path) != 0)
1289     return FALSE;
1290
1291   if ((a->flags & BUS_MATCH_INTERFACE) &&
1292       strcmp (a->interface, b->interface) != 0)
1293     return FALSE;
1294
1295   if ((a->flags & BUS_MATCH_SENDER) &&
1296       strcmp (a->sender, b->sender) != 0)
1297     return FALSE;
1298
1299   if ((a->flags & BUS_MATCH_DESTINATION) &&
1300       strcmp (a->destination, b->destination) != 0)
1301     return FALSE;
1302
1303   if (a->flags & BUS_MATCH_ARGS)
1304     {
1305       int i;
1306
1307       if (a->args_len != b->args_len)
1308         return FALSE;
1309
1310       i = 0;
1311       while (i < a->args_len)
1312         {
1313           int length;
1314
1315           if ((a->args[i] != NULL) != (b->args[i] != NULL))
1316             return FALSE;
1317
1318           if (a->arg_lens[i] != b->arg_lens[i])
1319             return FALSE;
1320
1321           length = a->arg_lens[i] & ~BUS_MATCH_ARG_IS_PATH;
1322
1323           if (a->args[i] != NULL)
1324             {
1325               _dbus_assert (b->args[i] != NULL);
1326               if (memcmp (a->args[i], b->args[i], length) != 0)
1327                 return FALSE;
1328             }
1329
1330           ++i;
1331         }
1332     }
1333
1334   return TRUE;
1335 }
1336
1337 static void
1338 bus_matchmaker_remove_rule_link (DBusList       **rules,
1339                                  DBusList        *link)
1340 {
1341   BusMatchRule *rule = link->data;
1342
1343   bus_connection_remove_match_rule (rule->matches_go_to, rule);
1344   _dbus_list_remove_link (rules, link);
1345
1346 #ifdef DBUS_ENABLE_VERBOSE_MODE
1347   {
1348     char *s = match_rule_to_string (rule);
1349
1350     _dbus_verbose ("Removed match rule %s for connection %p\n",
1351                    s, rule->matches_go_to);
1352     dbus_free (s);
1353   }
1354 #endif
1355
1356   bus_match_rule_unref (rule);
1357 }
1358
1359 void
1360 bus_matchmaker_remove_rule (BusMatchmaker   *matchmaker,
1361                             BusMatchRule    *rule)
1362 {
1363   DBusList **rules;
1364
1365   _dbus_verbose ("Removing rule with message_type %d, interface %s\n",
1366                  rule->message_type,
1367                  rule->interface != NULL ? rule->interface : "<null>");
1368
1369   bus_connection_remove_match_rule (rule->matches_go_to, rule);
1370
1371   rules = bus_matchmaker_get_rules (matchmaker, rule->message_type,
1372                                     rule->interface, FALSE);
1373
1374   /* We should only be asked to remove a rule by identity right after it was
1375    * added, so there should be a list for it.
1376    */
1377   _dbus_assert (rules != NULL);
1378
1379   _dbus_list_remove (rules, rule);
1380   bus_matchmaker_gc_rules (matchmaker, rule->message_type, rule->interface,
1381       rules);
1382
1383 #ifdef DBUS_ENABLE_VERBOSE_MODE
1384   {
1385     char *s = match_rule_to_string (rule);
1386
1387     _dbus_verbose ("Removed match rule %s for connection %p\n",
1388                    s, rule->matches_go_to);
1389     dbus_free (s);
1390   }
1391 #endif
1392
1393   bus_match_rule_unref (rule);
1394 }
1395
1396 /* Remove a single rule which is equal to the given rule by value */
1397 dbus_bool_t
1398 bus_matchmaker_remove_rule_by_value (BusMatchmaker   *matchmaker,
1399                                      BusMatchRule    *value,
1400                                      DBusError       *error)
1401 {
1402   DBusList **rules;
1403   DBusList *link = NULL;
1404
1405   _dbus_verbose ("Removing rule by value with message_type %d, interface %s\n",
1406                  value->message_type,
1407                  value->interface != NULL ? value->interface : "<null>");
1408
1409   rules = bus_matchmaker_get_rules (matchmaker, value->message_type,
1410       value->interface, FALSE);
1411
1412   if (rules != NULL)
1413     {
1414       /* we traverse backward because bus_connection_remove_match_rule()
1415        * removes the most-recently-added rule
1416        */
1417       link = _dbus_list_get_last_link (rules);
1418       while (link != NULL)
1419         {
1420           BusMatchRule *rule;
1421           DBusList *prev;
1422
1423           rule = link->data;
1424           prev = _dbus_list_get_prev_link (rules, link);
1425
1426           if (match_rule_equal (rule, value))
1427             {
1428               bus_matchmaker_remove_rule_link (rules, link);
1429               break;
1430             }
1431
1432           link = prev;
1433         }
1434     }
1435
1436   if (link == NULL)
1437     {
1438       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_NOT_FOUND,
1439                       "The given match rule wasn't found and can't be removed");
1440       return FALSE;
1441     }
1442
1443   bus_matchmaker_gc_rules (matchmaker, value->message_type, value->interface,
1444       rules);
1445
1446   return TRUE;
1447 }
1448
1449 static void
1450 rule_list_remove_by_connection (DBusList       **rules,
1451                                 DBusConnection  *connection)
1452 {
1453   DBusList *link;
1454
1455   link = _dbus_list_get_first_link (rules);
1456   while (link != NULL)
1457     {
1458       BusMatchRule *rule;
1459       DBusList *next;
1460
1461       rule = link->data;
1462       next = _dbus_list_get_next_link (rules, link);
1463
1464       if (rule->matches_go_to == connection)
1465         {
1466           bus_matchmaker_remove_rule_link (rules, link);
1467         }
1468       else if (((rule->flags & BUS_MATCH_SENDER) && *rule->sender == ':') ||
1469                ((rule->flags & BUS_MATCH_DESTINATION) && *rule->destination == ':'))
1470         {
1471           /* The rule matches to/from a base service, see if it's the
1472            * one being disconnected, since we know this service name
1473            * will never be recycled.
1474            */
1475           const char *name;
1476
1477           name = bus_connection_get_name (connection);
1478           _dbus_assert (name != NULL); /* because we're an active connection */
1479
1480           if (((rule->flags & BUS_MATCH_SENDER) &&
1481                strcmp (rule->sender, name) == 0) ||
1482               ((rule->flags & BUS_MATCH_DESTINATION) &&
1483                strcmp (rule->destination, name) == 0))
1484             {
1485               bus_matchmaker_remove_rule_link (rules, link);
1486             }
1487         }
1488
1489       link = next;
1490     }
1491 }
1492
1493 void
1494 bus_matchmaker_disconnected (BusMatchmaker   *matchmaker,
1495                              DBusConnection  *connection)
1496 {
1497   int i;
1498
1499   /* FIXME
1500    *
1501    * This scans all match rules on the bus. We could avoid that
1502    * for the rules belonging to the connection, since we keep
1503    * a list of those; but for the rules that just refer to
1504    * the connection we'd need to do something more elaborate.
1505    */
1506
1507   _dbus_assert (bus_connection_is_active (connection));
1508
1509   _dbus_verbose ("Removing all rules for connection %p\n", connection);
1510
1511   for (i = DBUS_MESSAGE_TYPE_INVALID; i < DBUS_NUM_MESSAGE_TYPES; i++)
1512     {
1513       RulePool *p = matchmaker->rules_by_type + i;
1514       DBusHashIter iter;
1515
1516       rule_list_remove_by_connection (&p->rules_without_iface, connection);
1517
1518       _dbus_hash_iter_init (p->rules_by_iface, &iter);
1519       while (_dbus_hash_iter_next (&iter))
1520         {
1521           DBusList **items = _dbus_hash_iter_get_value (&iter);
1522
1523           rule_list_remove_by_connection (items, connection);
1524
1525           if (*items == NULL)
1526             _dbus_hash_iter_remove_entry (&iter);
1527         }
1528     }
1529 }
1530
1531 static dbus_bool_t
1532 connection_is_primary_owner (DBusConnection *connection,
1533                              const char     *service_name)
1534 {
1535   BusService *service;
1536   DBusString str;
1537   BusRegistry *registry;
1538
1539   _dbus_assert (connection != NULL);
1540
1541   registry = bus_connection_get_registry (connection);
1542
1543   _dbus_string_init_const (&str, service_name);
1544   service = bus_registry_lookup (registry, &str);
1545
1546   if (service == NULL)
1547     return FALSE; /* Service doesn't exist so connection can't own it. */
1548
1549   return bus_service_get_primary_owners_connection (service) == connection;
1550 }
1551
1552 static dbus_bool_t
1553 match_rule_matches (BusMatchRule    *rule,
1554                     DBusConnection  *sender,
1555                     DBusConnection  *addressed_recipient,
1556                     DBusMessage     *message,
1557                     BusMatchFlags    already_matched)
1558 {
1559   int flags;
1560
1561   /* All features of the match rule are AND'd together,
1562    * so FALSE if any of them don't match.
1563    */
1564
1565   /* sender/addressed_recipient of #NULL may mean bus driver,
1566    * or for addressed_recipient may mean a message with no
1567    * specific recipient (i.e. a signal)
1568    */
1569
1570   /* Don't bother re-matching features we've already checked implicitly. */
1571   flags = rule->flags & (~already_matched);
1572
1573   if (flags & BUS_MATCH_MESSAGE_TYPE)
1574     {
1575       _dbus_assert (rule->message_type != DBUS_MESSAGE_TYPE_INVALID);
1576
1577       if (rule->message_type != dbus_message_get_type (message))
1578         return FALSE;
1579     }
1580
1581   if (flags & BUS_MATCH_INTERFACE)
1582     {
1583       const char *iface;
1584
1585       _dbus_assert (rule->interface != NULL);
1586
1587       iface = dbus_message_get_interface (message);
1588       if (iface == NULL)
1589         return FALSE;
1590
1591       if (strcmp (iface, rule->interface) != 0)
1592         return FALSE;
1593     }
1594
1595   if (flags & BUS_MATCH_MEMBER)
1596     {
1597       const char *member;
1598
1599       _dbus_assert (rule->member != NULL);
1600
1601       member = dbus_message_get_member (message);
1602       if (member == NULL)
1603         return FALSE;
1604
1605       if (strcmp (member, rule->member) != 0)
1606         return FALSE;
1607     }
1608
1609   if (flags & BUS_MATCH_SENDER)
1610     {
1611       _dbus_assert (rule->sender != NULL);
1612
1613       if (sender == NULL)
1614         {
1615           if (strcmp (rule->sender,
1616                       DBUS_SERVICE_DBUS) != 0)
1617             return FALSE;
1618         }
1619       else
1620         {
1621           if (!connection_is_primary_owner (sender, rule->sender))
1622             return FALSE;
1623         }
1624     }
1625
1626   if (flags & BUS_MATCH_DESTINATION)
1627     {
1628       const char *destination;
1629
1630       _dbus_assert (rule->destination != NULL);
1631
1632       destination = dbus_message_get_destination (message);
1633       if (destination == NULL)
1634         return FALSE;
1635
1636       if (addressed_recipient == NULL)
1637         {
1638           if (strcmp (rule->destination,
1639                       DBUS_SERVICE_DBUS) != 0)
1640             return FALSE;
1641         }
1642       else
1643         {
1644           if (!connection_is_primary_owner (addressed_recipient, rule->destination))
1645             return FALSE;
1646         }
1647     }
1648
1649   if (flags & BUS_MATCH_PATH)
1650     {
1651       const char *path;
1652
1653       _dbus_assert (rule->path != NULL);
1654
1655       path = dbus_message_get_path (message);
1656       if (path == NULL)
1657         return FALSE;
1658
1659       if (strcmp (path, rule->path) != 0)
1660         return FALSE;
1661     }
1662
1663   if (flags & BUS_MATCH_ARGS)
1664     {
1665       int i;
1666       DBusMessageIter iter;
1667
1668       _dbus_assert (rule->args != NULL);
1669
1670       dbus_message_iter_init (message, &iter);
1671
1672       i = 0;
1673       while (i < rule->args_len)
1674         {
1675           int current_type;
1676           const char *expected_arg;
1677           int expected_length;
1678           dbus_bool_t is_path;
1679
1680           expected_arg = rule->args[i];
1681           expected_length = rule->arg_lens[i] & ~BUS_MATCH_ARG_IS_PATH;
1682           is_path = (rule->arg_lens[i] & BUS_MATCH_ARG_IS_PATH) != 0;
1683
1684           current_type = dbus_message_iter_get_arg_type (&iter);
1685
1686           if (expected_arg != NULL)
1687             {
1688               const char *actual_arg;
1689               int actual_length;
1690
1691               if (current_type != DBUS_TYPE_STRING)
1692                 return FALSE;
1693
1694               actual_arg = NULL;
1695               dbus_message_iter_get_basic (&iter, &actual_arg);
1696               _dbus_assert (actual_arg != NULL);
1697
1698               actual_length = strlen (actual_arg);
1699
1700               if (is_path)
1701                 {
1702                   if (actual_length < expected_length &&
1703                       actual_arg[actual_length - 1] != '/')
1704                     return FALSE;
1705
1706                   if (expected_length < actual_length &&
1707                       expected_arg[expected_length - 1] != '/')
1708                     return FALSE;
1709
1710                   if (memcmp (actual_arg, expected_arg,
1711                               MIN (actual_length, expected_length)) != 0)
1712                     return FALSE;
1713                 }
1714               else
1715                 {
1716                   if (expected_length != actual_length ||
1717                       memcmp (expected_arg, actual_arg, expected_length) != 0)
1718                     return FALSE;
1719                 }
1720
1721             }
1722
1723           if (current_type != DBUS_TYPE_INVALID)
1724             dbus_message_iter_next (&iter);
1725
1726           ++i;
1727         }
1728     }
1729
1730   return TRUE;
1731 }
1732
1733 static dbus_bool_t
1734 get_recipients_from_list (DBusList       **rules,
1735                           DBusConnection  *sender,
1736                           DBusConnection  *addressed_recipient,
1737                           DBusMessage     *message,
1738                           DBusList       **recipients_p)
1739 {
1740   DBusList *link;
1741
1742   if (rules == NULL)
1743     return TRUE;
1744
1745   link = _dbus_list_get_first_link (rules);
1746   while (link != NULL)
1747     {
1748       BusMatchRule *rule;
1749
1750       rule = link->data;
1751
1752 #ifdef DBUS_ENABLE_VERBOSE_MODE
1753       {
1754         char *s = match_rule_to_string (rule);
1755
1756         _dbus_verbose ("Checking whether message matches rule %s for connection %p\n",
1757                        s, rule->matches_go_to);
1758         dbus_free (s);
1759       }
1760 #endif
1761
1762       if (match_rule_matches (rule,
1763                               sender, addressed_recipient, message,
1764                               BUS_MATCH_MESSAGE_TYPE | BUS_MATCH_INTERFACE))
1765         {
1766           _dbus_verbose ("Rule matched\n");
1767
1768           /* Append to the list if we haven't already */
1769           if (bus_connection_mark_stamp (rule->matches_go_to))
1770             {
1771               if (!_dbus_list_append (recipients_p, rule->matches_go_to))
1772                 return FALSE;
1773             }
1774 #ifdef DBUS_ENABLE_VERBOSE_MODE
1775           else
1776             {
1777               _dbus_verbose ("Connection already receiving this message, so not adding again\n");
1778             }
1779 #endif /* DBUS_ENABLE_VERBOSE_MODE */
1780         }
1781
1782       link = _dbus_list_get_next_link (rules, link);
1783     }
1784
1785   return TRUE;
1786 }
1787
1788 dbus_bool_t
1789 bus_matchmaker_get_recipients (BusMatchmaker   *matchmaker,
1790                                BusConnections  *connections,
1791                                DBusConnection  *sender,
1792                                DBusConnection  *addressed_recipient,
1793                                DBusMessage     *message,
1794                                DBusList       **recipients_p)
1795 {
1796   int type;
1797   const char *interface;
1798   DBusList **neither, **just_type, **just_iface, **both;
1799
1800   _dbus_assert (*recipients_p == NULL);
1801
1802   /* This avoids sending same message to the same connection twice.
1803    * Purpose of the stamp instead of a bool is to avoid iterating over
1804    * all connections resetting the bool each time.
1805    */
1806   bus_connections_increment_stamp (connections);
1807
1808   /* addressed_recipient is already receiving the message, don't add to list.
1809    * NULL addressed_recipient means either bus driver, or this is a signal
1810    * and thus lacks a specific addressed_recipient.
1811    */
1812   if (addressed_recipient != NULL)
1813     bus_connection_mark_stamp (addressed_recipient);
1814
1815   type = dbus_message_get_type (message);
1816   interface = dbus_message_get_interface (message);
1817
1818   neither = bus_matchmaker_get_rules (matchmaker, DBUS_MESSAGE_TYPE_INVALID,
1819       NULL, FALSE);
1820   just_type = just_iface = both = NULL;
1821
1822   if (interface != NULL)
1823     just_iface = bus_matchmaker_get_rules (matchmaker,
1824         DBUS_MESSAGE_TYPE_INVALID, interface, FALSE);
1825
1826   if (type > DBUS_MESSAGE_TYPE_INVALID && type < DBUS_NUM_MESSAGE_TYPES)
1827     {
1828       just_type = bus_matchmaker_get_rules (matchmaker, type, NULL, FALSE);
1829
1830       if (interface != NULL)
1831         both = bus_matchmaker_get_rules (matchmaker, type, interface, FALSE);
1832     }
1833
1834   if (!(get_recipients_from_list (neither, sender, addressed_recipient,
1835                                   message, recipients_p) &&
1836         get_recipients_from_list (just_iface, sender, addressed_recipient,
1837                                   message, recipients_p) &&
1838         get_recipients_from_list (just_type, sender, addressed_recipient,
1839                                   message, recipients_p) &&
1840         get_recipients_from_list (both, sender, addressed_recipient,
1841                                   message, recipients_p)))
1842     {
1843       _dbus_list_clear (recipients_p);
1844       return FALSE;
1845     }
1846
1847   return TRUE;
1848 }
1849
1850 #ifdef DBUS_BUILD_TESTS
1851 #include "test.h"
1852 #include <stdlib.h>
1853
1854 static BusMatchRule*
1855 check_parse (dbus_bool_t should_succeed,
1856              const char *text)
1857 {
1858   BusMatchRule *rule;
1859   DBusString str;
1860   DBusError error;
1861
1862   dbus_error_init (&error);
1863
1864   _dbus_string_init_const (&str, text);
1865
1866   rule = bus_match_rule_parse (NULL, &str, &error);
1867   if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1868     {
1869       dbus_error_free (&error);
1870       return NULL;
1871     }
1872
1873   if (should_succeed && rule == NULL)
1874     {
1875       _dbus_warn ("Failed to parse: %s: %s: \"%s\"\n",
1876                   error.name, error.message,
1877                   _dbus_string_get_const_data (&str));
1878       exit (1);
1879     }
1880
1881   if (!should_succeed && rule != NULL)
1882     {
1883       _dbus_warn ("Failed to fail to parse: \"%s\"\n",
1884                   _dbus_string_get_const_data (&str));
1885       exit (1);
1886     }
1887
1888   dbus_error_free (&error);
1889
1890   return rule;
1891 }
1892
1893 static void
1894 assert_large_rule (BusMatchRule *rule)
1895 {
1896   _dbus_assert (rule->flags & BUS_MATCH_MESSAGE_TYPE);
1897   _dbus_assert (rule->flags & BUS_MATCH_SENDER);
1898   _dbus_assert (rule->flags & BUS_MATCH_INTERFACE);
1899   _dbus_assert (rule->flags & BUS_MATCH_MEMBER);
1900   _dbus_assert (rule->flags & BUS_MATCH_DESTINATION);
1901   _dbus_assert (rule->flags & BUS_MATCH_PATH);
1902
1903   _dbus_assert (rule->message_type == DBUS_MESSAGE_TYPE_SIGNAL);
1904   _dbus_assert (rule->interface != NULL);
1905   _dbus_assert (rule->member != NULL);
1906   _dbus_assert (rule->sender != NULL);
1907   _dbus_assert (rule->destination != NULL);
1908   _dbus_assert (rule->path != NULL);
1909
1910   _dbus_assert (strcmp (rule->interface, "org.freedesktop.DBusInterface") == 0);
1911   _dbus_assert (strcmp (rule->sender, "org.freedesktop.DBusSender") == 0);
1912   _dbus_assert (strcmp (rule->member, "Foo") == 0);
1913   _dbus_assert (strcmp (rule->path, "/bar/foo") == 0);
1914   _dbus_assert (strcmp (rule->destination, ":452345.34") == 0);
1915 }
1916
1917 static dbus_bool_t
1918 test_parsing (void *data)
1919 {
1920   BusMatchRule *rule;
1921
1922   rule = check_parse (TRUE, "type='signal',sender='org.freedesktop.DBusSender',interface='org.freedesktop.DBusInterface',member='Foo',path='/bar/foo',destination=':452345.34'");
1923   if (rule != NULL)
1924     {
1925       assert_large_rule (rule);
1926       bus_match_rule_unref (rule);
1927     }
1928
1929   /* With extra whitespace and useless quotes */
1930   rule = check_parse (TRUE, "    type='signal',  \tsender='org.freedes''ktop.DBusSender',   interface='org.freedesktop.DBusInterface''''', \tmember='Foo',path='/bar/foo',destination=':452345.34'''''");
1931   if (rule != NULL)
1932     {
1933       assert_large_rule (rule);
1934       bus_match_rule_unref (rule);
1935     }
1936
1937
1938   /* A simple signal connection */
1939   rule = check_parse (TRUE, "type='signal',path='/foo',interface='org.Bar'");
1940   if (rule != NULL)
1941     {
1942       _dbus_assert (rule->flags & BUS_MATCH_MESSAGE_TYPE);
1943       _dbus_assert (rule->flags & BUS_MATCH_INTERFACE);
1944       _dbus_assert (rule->flags & BUS_MATCH_PATH);
1945
1946       _dbus_assert (rule->message_type == DBUS_MESSAGE_TYPE_SIGNAL);
1947       _dbus_assert (rule->interface != NULL);
1948       _dbus_assert (rule->path != NULL);
1949
1950       _dbus_assert (strcmp (rule->interface, "org.Bar") == 0);
1951       _dbus_assert (strcmp (rule->path, "/foo") == 0);
1952
1953       bus_match_rule_unref (rule);
1954     }
1955
1956   /* argN */
1957   rule = check_parse (TRUE, "arg0='foo'");
1958   if (rule != NULL)
1959     {
1960       _dbus_assert (rule->flags == BUS_MATCH_ARGS);
1961       _dbus_assert (rule->args != NULL);
1962       _dbus_assert (rule->args_len == 1);
1963       _dbus_assert (rule->args[0] != NULL);
1964       _dbus_assert (rule->args[1] == NULL);
1965       _dbus_assert (strcmp (rule->args[0], "foo") == 0);
1966
1967       bus_match_rule_unref (rule);
1968     }
1969
1970   rule = check_parse (TRUE, "arg1='foo'");
1971   if (rule != NULL)
1972     {
1973       _dbus_assert (rule->flags == BUS_MATCH_ARGS);
1974       _dbus_assert (rule->args != NULL);
1975       _dbus_assert (rule->args_len == 2);
1976       _dbus_assert (rule->args[0] == NULL);
1977       _dbus_assert (rule->args[1] != NULL);
1978       _dbus_assert (rule->args[2] == NULL);
1979       _dbus_assert (strcmp (rule->args[1], "foo") == 0);
1980
1981       bus_match_rule_unref (rule);
1982     }
1983
1984   rule = check_parse (TRUE, "arg2='foo'");
1985   if (rule != NULL)
1986     {
1987       _dbus_assert (rule->flags == BUS_MATCH_ARGS);
1988       _dbus_assert (rule->args != NULL);
1989       _dbus_assert (rule->args_len == 3);
1990       _dbus_assert (rule->args[0] == NULL);
1991       _dbus_assert (rule->args[1] == NULL);
1992       _dbus_assert (rule->args[2] != NULL);
1993       _dbus_assert (rule->args[3] == NULL);
1994       _dbus_assert (strcmp (rule->args[2], "foo") == 0);
1995
1996       bus_match_rule_unref (rule);
1997     }
1998
1999   rule = check_parse (TRUE, "arg40='foo'");
2000   if (rule != NULL)
2001     {
2002       _dbus_assert (rule->flags == BUS_MATCH_ARGS);
2003       _dbus_assert (rule->args != NULL);
2004       _dbus_assert (rule->args_len == 41);
2005       _dbus_assert (rule->args[0] == NULL);
2006       _dbus_assert (rule->args[1] == NULL);
2007       _dbus_assert (rule->args[40] != NULL);
2008       _dbus_assert (rule->args[41] == NULL);
2009       _dbus_assert (strcmp (rule->args[40], "foo") == 0);
2010
2011       bus_match_rule_unref (rule);
2012     }
2013
2014   rule = check_parse (TRUE, "arg63='foo'");
2015   if (rule != NULL)
2016     {
2017       _dbus_assert (rule->flags == BUS_MATCH_ARGS);
2018       _dbus_assert (rule->args != NULL);
2019       _dbus_assert (rule->args_len == 64);
2020       _dbus_assert (rule->args[0] == NULL);
2021       _dbus_assert (rule->args[1] == NULL);
2022       _dbus_assert (rule->args[63] != NULL);
2023       _dbus_assert (rule->args[64] == NULL);
2024       _dbus_assert (strcmp (rule->args[63], "foo") == 0);
2025
2026       bus_match_rule_unref (rule);
2027     }
2028
2029   /* Too-large argN */
2030   rule = check_parse (FALSE, "arg300='foo'");
2031   _dbus_assert (rule == NULL);
2032   rule = check_parse (FALSE, "arg64='foo'");
2033   _dbus_assert (rule == NULL);
2034
2035   /* No N in argN */
2036   rule = check_parse (FALSE, "arg='foo'");
2037   _dbus_assert (rule == NULL);
2038   rule = check_parse (FALSE, "argv='foo'");
2039   _dbus_assert (rule == NULL);
2040   rule = check_parse (FALSE, "arg3junk='foo'");
2041   _dbus_assert (rule == NULL);
2042   rule = check_parse (FALSE, "argument='foo'");
2043   _dbus_assert (rule == NULL);
2044
2045   /* Reject duplicates */
2046   rule = check_parse (FALSE, "type='signal',type='method_call'");
2047   _dbus_assert (rule == NULL);
2048
2049   /* Duplicates with the argN code */
2050   rule = check_parse (FALSE, "arg0='foo',arg0='bar'");
2051   _dbus_assert (rule == NULL);
2052   rule = check_parse (FALSE, "arg3='foo',arg3='bar'");
2053   _dbus_assert (rule == NULL);
2054   rule = check_parse (FALSE, "arg30='foo',arg30='bar'");
2055   _dbus_assert (rule == NULL);
2056
2057   /* Reject broken keys */
2058   rule = check_parse (FALSE, "blah='signal'");
2059   _dbus_assert (rule == NULL);
2060
2061   /* Reject broken values */
2062   rule = check_parse (FALSE, "type='chouin'");
2063   _dbus_assert (rule == NULL);
2064   rule = check_parse (FALSE, "interface='abc@def++'");
2065   _dbus_assert (rule == NULL);
2066   rule = check_parse (FALSE, "service='youpi'");
2067   _dbus_assert (rule == NULL);
2068
2069   /* Allow empty rule */
2070   rule = check_parse (TRUE, "");
2071   if (rule != NULL)
2072     {
2073       _dbus_assert (rule->flags == 0);
2074
2075       bus_match_rule_unref (rule);
2076     }
2077
2078   /* All-whitespace rule is the same as empty */
2079   rule = check_parse (TRUE, "    \t");
2080   if (rule != NULL)
2081     {
2082       _dbus_assert (rule->flags == 0);
2083
2084       bus_match_rule_unref (rule);
2085     }
2086
2087   /* But with non-whitespace chars and no =value, it's not OK */
2088   rule = check_parse (FALSE, "type");
2089   _dbus_assert (rule == NULL);
2090
2091   return TRUE;
2092 }
2093
2094 static struct {
2095   const char *first;
2096   const char *second;
2097 } equality_tests[] = {
2098   { "type='signal'", "type='signal'" },
2099   { "type='signal',interface='foo.bar'", "interface='foo.bar',type='signal'" },
2100   { "type='signal',member='bar'", "member='bar',type='signal'" },
2101   { "type='method_call',sender=':1.0'", "sender=':1.0',type='method_call'" },
2102   { "type='method_call',destination=':1.0'", "destination=':1.0',type='method_call'" },
2103   { "type='method_call',path='/foo/bar'", "path='/foo/bar',type='method_call'" },
2104   { "type='method_call',arg0='blah'", "arg0='blah',type='method_call'" },
2105   { "type='method_call',arg0='boo'", "arg0='boo',type='method_call'" },
2106   { "type='method_call',arg0='blah',arg1='baz'", "arg0='blah',arg1='baz',type='method_call'" },
2107   { "type='method_call',arg3='foosh'", "arg3='foosh',type='method_call'" },
2108   { "arg3='fool'", "arg3='fool'" },
2109   { "member='food'", "member='food'" }
2110 };
2111
2112 static void
2113 test_equality (void)
2114 {
2115   int i;
2116
2117   i = 0;
2118   while (i < _DBUS_N_ELEMENTS (equality_tests))
2119     {
2120       BusMatchRule *first;
2121       BusMatchRule *second;
2122       int j;
2123
2124       first = check_parse (TRUE, equality_tests[i].first);
2125       _dbus_assert (first != NULL);
2126       second = check_parse (TRUE, equality_tests[i].second);
2127       _dbus_assert (second != NULL);
2128
2129       if (!match_rule_equal (first, second))
2130         {
2131           _dbus_warn ("rule %s and %s should have been equal\n",
2132                       equality_tests[i].first,
2133                       equality_tests[i].second);
2134           exit (1);
2135         }
2136
2137       bus_match_rule_unref (second);
2138
2139       /* Check that the rule is not equal to any of the
2140        * others besides its pair match
2141        */
2142       j = 0;
2143       while (j < _DBUS_N_ELEMENTS (equality_tests))
2144         {
2145           if (i != j)
2146             {
2147               second = check_parse (TRUE, equality_tests[j].second);
2148
2149               if (match_rule_equal (first, second))
2150                 {
2151                   _dbus_warn ("rule %s and %s should not have been equal\n",
2152                               equality_tests[i].first,
2153                               equality_tests[j].second);
2154                   exit (1);
2155                 }
2156
2157               bus_match_rule_unref (second);
2158             }
2159
2160           ++j;
2161         }
2162
2163       bus_match_rule_unref (first);
2164
2165       ++i;
2166     }
2167 }
2168
2169 static const char*
2170 should_match_message_1[] = {
2171   "type='signal'",
2172   "member='Frobated'",
2173   "arg0='foobar'",
2174   "type='signal',member='Frobated'",
2175   "type='signal',member='Frobated',arg0='foobar'",
2176   "member='Frobated',arg0='foobar'",
2177   "type='signal',arg0='foobar'",
2178   NULL
2179 };
2180
2181 static const char*
2182 should_not_match_message_1[] = {
2183   "type='method_call'",
2184   "type='error'",
2185   "type='method_return'",
2186   "type='signal',member='Oopsed'",
2187   "arg0='blah'",
2188   "arg1='foobar'",
2189   "arg2='foobar'",
2190   "arg3='foobar'",
2191   "arg0='3'",
2192   "arg1='3'",
2193   "arg0='foobar',arg1='abcdef'",
2194   "arg0='foobar',arg1='abcdef',arg2='abcdefghi',arg3='abcdefghi',arg4='abcdefghi'",
2195   "arg0='foobar',arg1='abcdef',arg4='abcdefghi',arg3='abcdefghi',arg2='abcdefghi'",
2196   NULL
2197 };
2198
2199 static void
2200 check_matches (dbus_bool_t  expected_to_match,
2201                int          number,
2202                DBusMessage *message,
2203                const char  *rule_text)
2204 {
2205   BusMatchRule *rule;
2206   dbus_bool_t matched;
2207
2208   rule = check_parse (TRUE, rule_text);
2209   _dbus_assert (rule != NULL);
2210
2211   /* We can't test sender/destination rules since we pass NULL here */
2212   matched = match_rule_matches (rule, NULL, NULL, message, 0);
2213
2214   if (matched != expected_to_match)
2215     {
2216       _dbus_warn ("Expected rule %s to %s message %d, failed\n",
2217                   rule_text, expected_to_match ?
2218                   "match" : "not match", number);
2219       exit (1);
2220     }
2221
2222   bus_match_rule_unref (rule);
2223 }
2224
2225 static void
2226 check_matching (DBusMessage *message,
2227                 int          number,
2228                 const char **should_match,
2229                 const char **should_not_match)
2230 {
2231   int i;
2232
2233   i = 0;
2234   while (should_match[i] != NULL)
2235     {
2236       check_matches (TRUE, number, message, should_match[i]);
2237       ++i;
2238     }
2239
2240   i = 0;
2241   while (should_not_match[i] != NULL)
2242     {
2243       check_matches (FALSE, number, message, should_not_match[i]);
2244       ++i;
2245     }
2246 }
2247
2248 static void
2249 test_matching (void)
2250 {
2251   DBusMessage *message1;
2252   const char *v_STRING;
2253   dbus_int32_t v_INT32;
2254
2255   message1 = dbus_message_new (DBUS_MESSAGE_TYPE_SIGNAL);
2256   _dbus_assert (message1 != NULL);
2257   if (!dbus_message_set_member (message1, "Frobated"))
2258     _dbus_assert_not_reached ("oom");
2259
2260   v_STRING = "foobar";
2261   v_INT32 = 3;
2262   if (!dbus_message_append_args (message1,
2263                                  DBUS_TYPE_STRING, &v_STRING,
2264                                  DBUS_TYPE_INT32, &v_INT32,
2265                                  NULL))
2266     _dbus_assert_not_reached ("oom");
2267
2268   check_matching (message1, 1,
2269                   should_match_message_1,
2270                   should_not_match_message_1);
2271
2272   dbus_message_unref (message1);
2273 }
2274
2275 dbus_bool_t
2276 bus_signals_test (const DBusString *test_data_dir)
2277 {
2278   BusMatchmaker *matchmaker;
2279
2280   matchmaker = bus_matchmaker_new ();
2281   bus_matchmaker_ref (matchmaker);
2282   bus_matchmaker_unref (matchmaker);
2283   bus_matchmaker_unref (matchmaker);
2284
2285   if (!_dbus_test_oom_handling ("parsing match rules", test_parsing, NULL))
2286     _dbus_assert_not_reached ("Parsing match rules test failed");
2287
2288   test_equality ();
2289
2290   test_matching ();
2291
2292   return TRUE;
2293 }
2294
2295 #endif /* DBUS_BUILD_TESTS */
2296