2005-02-17 Colin Walters <walters@verbum.org>
[platform/upstream/dbus.git] / bus / signals.c
1 /* -*- mode: C; c-file-style: "gnu" -*- */
2 /* signals.c  Bus signal connection implementation
3  *
4  * Copyright (C) 2003  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  *
22  */
23 #include "signals.h"
24 #include "services.h"
25 #include "utils.h"
26 #include <dbus/dbus-marshal-validate.h>
27
28 struct BusMatchRule
29 {
30   int refcount;       /**< reference count */
31
32   DBusConnection *matches_go_to; /**< Owner of the rule */
33
34   unsigned int flags; /**< BusMatchFlags */
35
36   int   message_type;
37   char *interface;
38   char *member;
39   char *sender;
40   char *destination;
41   char *path;
42 };
43
44 BusMatchRule*
45 bus_match_rule_new (DBusConnection *matches_go_to)
46 {
47   BusMatchRule *rule;
48
49   rule = dbus_new0 (BusMatchRule, 1);
50   if (rule == NULL)
51     return NULL;
52
53   rule->refcount = 1;
54   rule->matches_go_to = matches_go_to;
55
56 #ifndef DBUS_BUILD_TESTS
57   _dbus_assert (rule->matches_go_to != NULL);
58 #endif
59   
60   return rule;
61 }
62
63 BusMatchRule *
64 bus_match_rule_ref (BusMatchRule *rule)
65 {
66   _dbus_assert (rule->refcount > 0);
67
68   rule->refcount += 1;
69
70   return rule;
71 }
72
73 void
74 bus_match_rule_unref (BusMatchRule *rule)
75 {
76   _dbus_assert (rule->refcount > 0);
77
78   rule->refcount -= 1;
79   if (rule->refcount == 0)
80     {
81       dbus_free (rule->interface);
82       dbus_free (rule->member);
83       dbus_free (rule->sender);
84       dbus_free (rule->destination);
85       dbus_free (rule->path);
86       dbus_free (rule);
87     }
88 }
89
90 #ifdef DBUS_ENABLE_VERBOSE_MODE
91 static char*
92 match_rule_to_string (BusMatchRule *rule)
93 {
94   DBusString str;
95   char *ret;
96   
97   if (!_dbus_string_init (&str))
98     {
99       char *s;
100       while ((s = _dbus_strdup ("nomem")) == NULL)
101         ; /* only OK for debug spew... */
102       return s;
103     }
104   
105   if (rule->flags & BUS_MATCH_MESSAGE_TYPE)
106     {
107       /* FIXME make type readable */
108       if (!_dbus_string_append_printf (&str, "type='%d'", rule->message_type))
109         goto nomem;
110     }
111
112   if (rule->flags & BUS_MATCH_INTERFACE)
113     {
114       if (_dbus_string_get_length (&str) > 0)
115         {
116           if (!_dbus_string_append (&str, ","))
117             goto nomem;
118         }
119       
120       if (!_dbus_string_append_printf (&str, "interface='%s'", rule->interface))
121         goto nomem;
122     }
123
124   if (rule->flags & BUS_MATCH_MEMBER)
125     {
126       if (_dbus_string_get_length (&str) > 0)
127         {
128           if (!_dbus_string_append (&str, ","))
129             goto nomem;
130         }
131       
132       if (!_dbus_string_append_printf (&str, "member='%s'", rule->member))
133         goto nomem;
134     }
135
136   if (rule->flags & BUS_MATCH_PATH)
137     {
138       if (_dbus_string_get_length (&str) > 0)
139         {
140           if (!_dbus_string_append (&str, ","))
141             goto nomem;
142         }
143       
144       if (!_dbus_string_append_printf (&str, "path='%s'", rule->path))
145         goto nomem;
146     }
147
148   if (rule->flags & BUS_MATCH_SENDER)
149     {
150       if (_dbus_string_get_length (&str) > 0)
151         {
152           if (!_dbus_string_append (&str, ","))
153             goto nomem;
154         }
155       
156       if (!_dbus_string_append_printf (&str, "sender='%s'", rule->sender))
157         goto nomem;
158     }
159
160   if (rule->flags & BUS_MATCH_DESTINATION)
161     {
162       if (_dbus_string_get_length (&str) > 0)
163         {
164           if (!_dbus_string_append (&str, ","))
165             goto nomem;
166         }
167       
168       if (!_dbus_string_append_printf (&str, "destination='%s'", rule->destination))
169         goto nomem;
170     }
171   
172   if (!_dbus_string_steal_data (&str, &ret))
173     goto nomem;
174
175   _dbus_string_free (&str);
176   return ret;
177   
178  nomem:
179   _dbus_string_free (&str);
180   {
181     char *s;
182     while ((s = _dbus_strdup ("nomem")) == NULL)
183       ;  /* only OK for debug spew... */
184     return s;
185   }
186 }
187 #endif /* DBUS_ENABLE_VERBOSE_MODE */
188
189 dbus_bool_t
190 bus_match_rule_set_message_type (BusMatchRule *rule,
191                                  int           type)
192 {
193   rule->flags |= BUS_MATCH_MESSAGE_TYPE;
194
195   rule->message_type = type;
196
197   return TRUE;
198 }
199
200 dbus_bool_t
201 bus_match_rule_set_interface (BusMatchRule *rule,
202                               const char   *interface)
203 {
204   char *new;
205
206   _dbus_assert (interface != NULL);
207
208   new = _dbus_strdup (interface);
209   if (new == NULL)
210     return FALSE;
211
212   rule->flags |= BUS_MATCH_INTERFACE;
213   dbus_free (rule->interface);
214   rule->interface = new;
215
216   return TRUE;
217 }
218
219 dbus_bool_t
220 bus_match_rule_set_member (BusMatchRule *rule,
221                            const char   *member)
222 {
223   char *new;
224
225   _dbus_assert (member != NULL);
226
227   new = _dbus_strdup (member);
228   if (new == NULL)
229     return FALSE;
230
231   rule->flags |= BUS_MATCH_MEMBER;
232   dbus_free (rule->member);
233   rule->member = new;
234
235   return TRUE;
236 }
237
238 dbus_bool_t
239 bus_match_rule_set_sender (BusMatchRule *rule,
240                            const char   *sender)
241 {
242   char *new;
243
244   _dbus_assert (sender != NULL);
245
246   new = _dbus_strdup (sender);
247   if (new == NULL)
248     return FALSE;
249
250   rule->flags |= BUS_MATCH_SENDER;
251   dbus_free (rule->sender);
252   rule->sender = new;
253
254   return TRUE;
255 }
256
257 dbus_bool_t
258 bus_match_rule_set_destination (BusMatchRule *rule,
259                                 const char   *destination)
260 {
261   char *new;
262
263   _dbus_assert (destination != NULL);
264
265   new = _dbus_strdup (destination);
266   if (new == NULL)
267     return FALSE;
268
269   rule->flags |= BUS_MATCH_DESTINATION;
270   dbus_free (rule->destination);
271   rule->destination = new;
272
273   return TRUE;
274 }
275
276 dbus_bool_t
277 bus_match_rule_set_path (BusMatchRule *rule,
278                          const char   *path)
279 {
280   char *new;
281
282   _dbus_assert (path != NULL);
283
284   new = _dbus_strdup (path);
285   if (new == NULL)
286     return FALSE;
287
288   rule->flags |= BUS_MATCH_PATH;
289   dbus_free (rule->path);
290   rule->path = new;
291
292   return TRUE;
293 }
294
295 #define ISWHITE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r'))
296
297 static dbus_bool_t
298 find_key (const DBusString *str,
299           int               start,
300           DBusString       *key,
301           int              *value_pos,
302           DBusError        *error)
303 {
304   const char *p;
305   const char *s;
306   const char *key_start;
307   const char *key_end;
308
309   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
310   
311   s = _dbus_string_get_const_data (str);
312
313   p = s + start;
314
315   while (*p && ISWHITE (*p))
316     ++p;
317
318   key_start = p;
319
320   while (*p && *p != '=' && !ISWHITE (*p))
321     ++p;
322
323   key_end = p;
324
325   while (*p && ISWHITE (*p))
326     ++p;
327   
328   if (key_start == key_end)
329     {
330       /* Empty match rules or trailing whitespace are OK */
331       *value_pos = p - s;
332       return TRUE;
333     }
334
335   if (*p != '=')
336     {
337       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
338                       "Match rule has a key with no subsequent '=' character");
339       return FALSE;
340     }
341   ++p;
342   
343   if (!_dbus_string_append_len (key, key_start, key_end - key_start))
344     {
345       BUS_SET_OOM (error);
346       return FALSE;
347     }
348
349   *value_pos = p - s;
350   
351   return TRUE;
352 }
353
354 static dbus_bool_t
355 find_value (const DBusString *str,
356             int               start,
357             const char       *key,
358             DBusString       *value,
359             int              *value_end,
360             DBusError        *error)
361 {
362   const char *p;
363   const char *s;
364   char quote_char;
365   int orig_len;
366
367   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
368   
369   orig_len = _dbus_string_get_length (value);
370   
371   s = _dbus_string_get_const_data (str);
372
373   p = s + start;
374
375   quote_char = '\0';
376
377   while (*p)
378     {
379       if (quote_char == '\0')
380         {
381           switch (*p)
382             {
383             case '\0':
384               goto done;
385
386             case '\'':
387               quote_char = '\'';
388               goto next;
389               
390             case ',':
391               ++p;
392               goto done;
393
394             case '\\':
395               quote_char = '\\';
396               goto next;
397               
398             default:
399               if (!_dbus_string_append_byte (value, *p))
400                 {
401                   BUS_SET_OOM (error);
402                   goto failed;
403                 }
404             }
405         }
406       else if (quote_char == '\\')
407         {
408           /* \ only counts as an escape if escaping a quote mark */
409           if (*p != '\'')
410             {
411               if (!_dbus_string_append_byte (value, '\\'))
412                 {
413                   BUS_SET_OOM (error);
414                   goto failed;
415                 }
416             }
417
418           if (!_dbus_string_append_byte (value, *p))
419             {
420               BUS_SET_OOM (error);
421               goto failed;
422             }
423           
424           quote_char = '\0';
425         }
426       else
427         {
428           _dbus_assert (quote_char == '\'');
429
430           if (*p == '\'')
431             {
432               quote_char = '\0';
433             }
434           else
435             {
436               if (!_dbus_string_append_byte (value, *p))
437                 {
438                   BUS_SET_OOM (error);
439                   goto failed;
440                 }
441             }
442         }
443
444     next:
445       ++p;
446     }
447
448  done:
449
450   if (quote_char == '\\')
451     {
452       if (!_dbus_string_append_byte (value, '\\'))
453         {
454           BUS_SET_OOM (error);
455           goto failed;
456         }
457     }
458   else if (quote_char == '\'')
459     {
460       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
461                       "Unbalanced quotation marks in match rule");
462       goto failed;
463     }
464   else
465     _dbus_assert (quote_char == '\0');
466
467   /* Zero-length values are allowed */
468   
469   *value_end = p - s;
470   
471   return TRUE;
472
473  failed:
474   _DBUS_ASSERT_ERROR_IS_SET (error);
475   _dbus_string_set_length (value, orig_len);
476   return FALSE;
477 }
478
479 /* duplicates aren't allowed so the real legitimate max is only 6 or
480  * so. Leaving extra so we don't have to bother to update it.
481  */
482 #define MAX_RULE_TOKENS 16
483
484 /* this is slightly too high level to be termed a "token"
485  * but let's not be pedantic.
486  */
487 typedef struct
488 {
489   char *key;
490   char *value;
491 } RuleToken;
492
493 static dbus_bool_t
494 tokenize_rule (const DBusString *rule_text,
495                RuleToken         tokens[MAX_RULE_TOKENS],
496                DBusError        *error) 
497 {
498   int i;
499   int pos;
500   DBusString key;
501   DBusString value;
502   dbus_bool_t retval;
503
504   retval = FALSE;
505   
506   if (!_dbus_string_init (&key))
507     {
508       BUS_SET_OOM (error);
509       return FALSE;
510     }
511
512   if (!_dbus_string_init (&value))
513     {
514       _dbus_string_free (&key);
515       BUS_SET_OOM (error);
516       return FALSE;
517     }
518
519   i = 0;
520   pos = 0;
521   while (i < MAX_RULE_TOKENS &&
522          pos < _dbus_string_get_length (rule_text))
523     {
524       _dbus_assert (tokens[i].key == NULL);
525       _dbus_assert (tokens[i].value == NULL);
526
527       if (!find_key (rule_text, pos, &key, &pos, error))
528         goto out;
529
530       if (_dbus_string_get_length (&key) == 0)
531         goto next;
532       
533       if (!_dbus_string_steal_data (&key, &tokens[i].key))
534         {
535           BUS_SET_OOM (error);
536           goto out;
537         }
538
539       if (!find_value (rule_text, pos, tokens[i].key, &value, &pos, error))
540         goto out;
541
542       if (!_dbus_string_steal_data (&value, &tokens[i].value))
543         {
544           BUS_SET_OOM (error);
545           goto out;
546         }
547
548     next:
549       ++i;
550     }
551
552   retval = TRUE;
553   
554  out:
555   if (!retval)
556     {
557       i = 0;
558       while (tokens[i].key || tokens[i].value)
559         {
560           dbus_free (tokens[i].key);
561           dbus_free (tokens[i].value);
562           tokens[i].key = NULL;
563           tokens[i].value = NULL;
564           ++i;
565         }
566     }
567   
568   _dbus_string_free (&key);
569   _dbus_string_free (&value);
570   
571   return retval;
572 }
573
574 /*
575  * The format is comma-separated with strings quoted with single quotes
576  * as for the shell (to escape a literal single quote, use '\'').
577  *
578  * type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='Foo',
579  * path='/bar/foo',destination=':452345.34'
580  *
581  */
582 BusMatchRule*
583 bus_match_rule_parse (DBusConnection   *matches_go_to,
584                       const DBusString *rule_text,
585                       DBusError        *error)
586 {
587   BusMatchRule *rule;
588   RuleToken tokens[MAX_RULE_TOKENS+1]; /* NULL termination + 1 */
589   int i;
590   
591   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
592
593   if (_dbus_string_get_length (rule_text) > DBUS_MAXIMUM_MATCH_RULE_LENGTH)
594     {
595       dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,
596                       "Match rule text is %d bytes, maximum is %d",
597                       _dbus_string_get_length (rule_text),
598                       DBUS_MAXIMUM_MATCH_RULE_LENGTH);
599       return NULL;
600     }
601   
602   memset (tokens, '\0', sizeof (tokens));
603   
604   rule = bus_match_rule_new (matches_go_to);
605   if (rule == NULL)
606     {
607       BUS_SET_OOM (error);
608       goto failed;
609     }
610   
611   if (!tokenize_rule (rule_text, tokens, error))
612     goto failed;
613   
614   i = 0;
615   while (tokens[i].key != NULL)
616     {
617       DBusString tmp_str;
618       int len;
619       const char *key = tokens[i].key;
620       const char *value = tokens[i].value;
621       
622       _dbus_string_init_const (&tmp_str, value);
623       len = _dbus_string_get_length (&tmp_str);
624
625       if (strcmp (key, "type") == 0)
626         {
627           int t;
628
629           if (rule->flags & BUS_MATCH_MESSAGE_TYPE)
630             {
631               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
632                               "Key %s specified twice in match rule\n", key);
633               goto failed;
634             }
635           
636           t = dbus_message_type_from_string (value);
637           
638           if (t == DBUS_MESSAGE_TYPE_INVALID)
639             {
640               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
641                               "Invalid message type (%s) in match rule\n", value);
642               goto failed;
643             }
644
645           if (!bus_match_rule_set_message_type (rule, t))
646             {
647               BUS_SET_OOM (error);
648               goto failed;
649             }
650         }
651       else if (strcmp (key, "sender") == 0)
652         {
653           if (rule->flags & BUS_MATCH_SENDER)
654             {
655               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
656                               "Key %s specified twice in match rule\n", key);
657               goto failed;
658             }
659
660           if (!_dbus_validate_bus_name (&tmp_str, 0, len))
661             {
662               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
663                               "Sender name '%s' is invalid\n", value);
664               goto failed;
665             }
666
667           if (!bus_match_rule_set_sender (rule, value))
668             {
669               BUS_SET_OOM (error);
670               goto failed;
671             }
672         }
673       else if (strcmp (key, "interface") == 0)
674         {
675           if (rule->flags & BUS_MATCH_INTERFACE)
676             {
677               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
678                               "Key %s specified twice in match rule\n", key);
679               goto failed;
680             }
681
682           if (!_dbus_validate_interface (&tmp_str, 0, len))
683             {
684               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
685                               "Interface name '%s' is invalid\n", value);
686               goto failed;
687             }
688
689           if (!bus_match_rule_set_interface (rule, value))
690             {
691               BUS_SET_OOM (error);
692               goto failed;
693             }
694         }
695       else if (strcmp (key, "member") == 0)
696         {
697           if (rule->flags & BUS_MATCH_MEMBER)
698             {
699               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
700                               "Key %s specified twice in match rule\n", key);
701               goto failed;
702             }
703
704           if (!_dbus_validate_member (&tmp_str, 0, len))
705             {
706               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
707                               "Member name '%s' is invalid\n", value);
708               goto failed;
709             }
710
711           if (!bus_match_rule_set_member (rule, value))
712             {
713               BUS_SET_OOM (error);
714               goto failed;
715             }
716         }
717       else if (strcmp (key, "path") == 0)
718         {
719           if (rule->flags & BUS_MATCH_PATH)
720             {
721               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
722                               "Key %s specified twice in match rule\n", key);
723               goto failed;
724             }
725
726           if (!_dbus_validate_path (&tmp_str, 0, len))
727             {
728               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
729                               "Path '%s' is invalid\n", value);
730               goto failed;
731             }
732
733           if (!bus_match_rule_set_path (rule, value))
734             {
735               BUS_SET_OOM (error);
736               goto failed;
737             }
738         }
739       else if (strcmp (key, "destination") == 0)
740         {
741           if (rule->flags & BUS_MATCH_DESTINATION)
742             {
743               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
744                               "Key %s specified twice in match rule\n", key);
745               goto failed;
746             }
747
748           if (!_dbus_validate_bus_name (&tmp_str, 0, len))
749             {
750               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
751                               "Destination name '%s' is invalid\n", value);
752               goto failed;
753             }
754
755           if (!bus_match_rule_set_destination (rule, value))
756             {
757               BUS_SET_OOM (error);
758               goto failed;
759             }
760         }
761       else
762         {
763           dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
764                           "Unknown key \"%s\" in match rule",
765                           key);
766           goto failed;
767         }
768
769       ++i;
770     }
771   
772
773   goto out;
774   
775  failed:
776   _DBUS_ASSERT_ERROR_IS_SET (error);
777   if (rule)
778     {
779       bus_match_rule_unref (rule);
780       rule = NULL;
781     }
782
783  out:
784   
785   i = 0;
786   while (tokens[i].key || tokens[i].value)
787     {
788       _dbus_assert (i < MAX_RULE_TOKENS);
789       dbus_free (tokens[i].key);
790       dbus_free (tokens[i].value);
791       ++i;
792     }
793   
794   return rule;
795 }
796
797 struct BusMatchmaker
798 {
799   int refcount;
800
801   DBusList *all_rules;
802 };
803
804 BusMatchmaker*
805 bus_matchmaker_new (void)
806 {
807   BusMatchmaker *matchmaker;
808
809   matchmaker = dbus_new0 (BusMatchmaker, 1);
810   if (matchmaker == NULL)
811     return NULL;
812
813   matchmaker->refcount = 1;
814   
815   return matchmaker;
816 }
817
818 BusMatchmaker *
819 bus_matchmaker_ref (BusMatchmaker *matchmaker)
820 {
821   _dbus_assert (matchmaker->refcount > 0);
822
823   matchmaker->refcount += 1;
824
825   return matchmaker;
826 }
827
828 void
829 bus_matchmaker_unref (BusMatchmaker *matchmaker)
830 {
831   _dbus_assert (matchmaker->refcount > 0);
832
833   matchmaker->refcount -= 1;
834   if (matchmaker->refcount == 0)
835     {
836       while (matchmaker->all_rules != NULL)
837         {
838           BusMatchRule *rule;
839
840           rule = matchmaker->all_rules->data;
841           bus_match_rule_unref (rule);
842           _dbus_list_remove_link (&matchmaker->all_rules,
843                                   matchmaker->all_rules);
844         }
845
846       dbus_free (matchmaker);
847     }
848 }
849
850 /* The rule can't be modified after it's added. */
851 dbus_bool_t
852 bus_matchmaker_add_rule (BusMatchmaker   *matchmaker,
853                          BusMatchRule    *rule)
854 {
855   _dbus_assert (bus_connection_is_active (rule->matches_go_to));
856
857   if (!_dbus_list_append (&matchmaker->all_rules, rule))
858     return FALSE;
859
860   if (!bus_connection_add_match_rule (rule->matches_go_to, rule))
861     {
862       _dbus_list_remove_last (&matchmaker->all_rules, rule);
863       return FALSE;
864     }
865   
866   bus_match_rule_ref (rule);
867
868 #ifdef DBUS_ENABLE_VERBOSE_MODE
869   {
870     char *s = match_rule_to_string (rule);
871
872     _dbus_verbose ("Added match rule %s to connection %p\n",
873                    s, rule->matches_go_to);
874     dbus_free (s);
875   }
876 #endif
877   
878   return TRUE;
879 }
880
881 static dbus_bool_t
882 match_rule_equal (BusMatchRule *a,
883                   BusMatchRule *b)
884 {
885   if (a->flags != b->flags)
886     return FALSE;
887
888   if ((a->flags & BUS_MATCH_MESSAGE_TYPE) &&
889       a->message_type != b->message_type)
890     return FALSE;
891
892   if ((a->flags & BUS_MATCH_MEMBER) &&
893       strcmp (a->member, b->member) != 0)
894     return FALSE;
895
896   if ((a->flags & BUS_MATCH_PATH) &&
897       strcmp (a->path, b->path) != 0)
898     return FALSE;
899   
900   if ((a->flags & BUS_MATCH_INTERFACE) &&
901       strcmp (a->interface, b->interface) != 0)
902     return FALSE;
903
904   if ((a->flags & BUS_MATCH_SENDER) &&
905       strcmp (a->sender, b->sender) != 0)
906     return FALSE;
907
908   if ((a->flags & BUS_MATCH_DESTINATION) &&
909       strcmp (a->destination, b->destination) != 0)
910     return FALSE;
911
912   return TRUE;
913 }
914
915 static void
916 bus_matchmaker_remove_rule_link (BusMatchmaker   *matchmaker,
917                                  DBusList        *link)
918 {
919   BusMatchRule *rule = link->data;
920   
921   bus_connection_remove_match_rule (rule->matches_go_to, rule);
922   _dbus_list_remove_link (&matchmaker->all_rules, link);
923
924 #ifdef DBUS_ENABLE_VERBOSE_MODE
925   {
926     char *s = match_rule_to_string (rule);
927
928     _dbus_verbose ("Removed match rule %s for connection %p\n",
929                    s, rule->matches_go_to);
930     dbus_free (s);
931   }
932 #endif
933   
934   bus_match_rule_unref (rule);  
935 }
936
937 void
938 bus_matchmaker_remove_rule (BusMatchmaker   *matchmaker,
939                             BusMatchRule    *rule)
940 {
941   bus_connection_remove_match_rule (rule->matches_go_to, rule);
942   _dbus_list_remove (&matchmaker->all_rules, rule);
943
944 #ifdef DBUS_ENABLE_VERBOSE_MODE
945   {
946     char *s = match_rule_to_string (rule);
947
948     _dbus_verbose ("Removed match rule %s for connection %p\n",
949                    s, rule->matches_go_to);
950     dbus_free (s);
951   }
952 #endif
953   
954   bus_match_rule_unref (rule);
955 }
956
957 /* Remove a single rule which is equal to the given rule by value */
958 dbus_bool_t
959 bus_matchmaker_remove_rule_by_value (BusMatchmaker   *matchmaker,
960                                      BusMatchRule    *value,
961                                      DBusError       *error)
962 {
963   /* FIXME this is an unoptimized linear scan */
964
965   DBusList *link;
966
967   /* we traverse backward because bus_connection_remove_match_rule()
968    * removes the most-recently-added rule
969    */
970   link = _dbus_list_get_last_link (&matchmaker->all_rules);
971   while (link != NULL)
972     {
973       BusMatchRule *rule;
974       DBusList *prev;
975
976       rule = link->data;
977       prev = _dbus_list_get_prev_link (&matchmaker->all_rules, link);
978
979       if (match_rule_equal (rule, value))
980         {
981           bus_matchmaker_remove_rule_link (matchmaker, link);
982           break;
983         }
984
985       link = prev;
986     }
987
988   if (link == NULL)
989     {
990       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_NOT_FOUND,
991                       "The given match rule wasn't found and can't be removed");
992       return FALSE;
993     }
994
995   return TRUE;
996 }
997
998 void
999 bus_matchmaker_disconnected (BusMatchmaker   *matchmaker,
1000                              DBusConnection  *disconnected)
1001 {
1002   DBusList *link;
1003
1004   /* FIXME
1005    *
1006    * This scans all match rules on the bus. We could avoid that
1007    * for the rules belonging to the connection, since we keep
1008    * a list of those; but for the rules that just refer to
1009    * the connection we'd need to do something more elaborate.
1010    * 
1011    */
1012   
1013   _dbus_assert (bus_connection_is_active (disconnected));
1014
1015   link = _dbus_list_get_first_link (&matchmaker->all_rules);
1016   while (link != NULL)
1017     {
1018       BusMatchRule *rule;
1019       DBusList *next;
1020
1021       rule = link->data;
1022       next = _dbus_list_get_next_link (&matchmaker->all_rules, link);
1023
1024       if (rule->matches_go_to == disconnected)
1025         {
1026           bus_matchmaker_remove_rule_link (matchmaker, link);
1027         }
1028       else if (((rule->flags & BUS_MATCH_SENDER) && *rule->sender == ':') ||
1029                ((rule->flags & BUS_MATCH_DESTINATION) && *rule->destination == ':'))
1030         {
1031           /* The rule matches to/from a base service, see if it's the
1032            * one being disconnected, since we know this service name
1033            * will never be recycled.
1034            */
1035           const char *name;
1036
1037           name = bus_connection_get_name (disconnected);
1038           _dbus_assert (name != NULL); /* because we're an active connection */
1039
1040           if (((rule->flags & BUS_MATCH_SENDER) &&
1041                strcmp (rule->sender, name) == 0) ||
1042               ((rule->flags & BUS_MATCH_DESTINATION) &&
1043                strcmp (rule->destination, name) == 0))
1044             {
1045               bus_matchmaker_remove_rule_link (matchmaker, link);
1046             }
1047         }
1048
1049       link = next;
1050     }
1051 }
1052
1053 static dbus_bool_t
1054 connection_is_primary_owner (DBusConnection *connection,
1055                              const char     *service_name)
1056 {
1057   BusService *service;
1058   DBusString str;
1059   BusRegistry *registry;
1060
1061   _dbus_assert (connection != NULL);
1062   
1063   registry = bus_connection_get_registry (connection);
1064
1065   _dbus_string_init_const (&str, service_name);
1066   service = bus_registry_lookup (registry, &str);
1067
1068   if (service == NULL)
1069     return FALSE; /* Service doesn't exist so connection can't own it. */
1070
1071   return bus_service_get_primary_owner (service) == connection;
1072 }
1073
1074 static dbus_bool_t
1075 match_rule_matches (BusMatchRule    *rule,
1076                     BusConnections  *connections,
1077                     DBusConnection  *sender,
1078                     DBusConnection  *addressed_recipient,
1079                     DBusMessage     *message)
1080 {
1081   /* All features of the match rule are AND'd together,
1082    * so FALSE if any of them don't match.
1083    */
1084
1085   /* sender/addressed_recipient of #NULL may mean bus driver,
1086    * or for addressed_recipient may mean a message with no
1087    * specific recipient (i.e. a signal)
1088    */
1089   
1090   if (rule->flags & BUS_MATCH_MESSAGE_TYPE)
1091     {
1092       _dbus_assert (rule->message_type != DBUS_MESSAGE_TYPE_INVALID);
1093
1094       if (rule->message_type != dbus_message_get_type (message))
1095         return FALSE;
1096     }
1097
1098   if (rule->flags & BUS_MATCH_INTERFACE)
1099     {
1100       const char *iface;
1101
1102       _dbus_assert (rule->interface != NULL);
1103
1104       iface = dbus_message_get_interface (message);
1105       if (iface == NULL)
1106         return FALSE;
1107
1108       if (strcmp (iface, rule->interface) != 0)
1109         return FALSE;
1110     }
1111
1112   if (rule->flags & BUS_MATCH_MEMBER)
1113     {
1114       const char *member;
1115
1116       _dbus_assert (rule->member != NULL);
1117
1118       member = dbus_message_get_member (message);
1119       if (member == NULL)
1120         return FALSE;
1121
1122       if (strcmp (member, rule->member) != 0)
1123         return FALSE;
1124     }
1125
1126   if (rule->flags & BUS_MATCH_SENDER)
1127     {
1128       _dbus_assert (rule->sender != NULL);
1129
1130       if (sender == NULL)
1131         {
1132           if (strcmp (rule->sender,
1133                       DBUS_SERVICE_DBUS) != 0)
1134             return FALSE;
1135         }
1136       else
1137         {
1138           if (!connection_is_primary_owner (sender, rule->sender))
1139             return FALSE;
1140         }
1141     }
1142
1143   if (rule->flags & BUS_MATCH_DESTINATION)
1144     {
1145       const char *destination;
1146
1147       _dbus_assert (rule->destination != NULL);
1148
1149       destination = dbus_message_get_destination (message);
1150       if (destination == NULL)
1151         return FALSE;
1152
1153       if (addressed_recipient == NULL)
1154         {          
1155           if (strcmp (rule->destination,
1156                       DBUS_SERVICE_DBUS) != 0)
1157             return FALSE;
1158         }
1159       else
1160         {
1161           if (!connection_is_primary_owner (addressed_recipient, rule->destination))
1162             return FALSE;
1163         }
1164     }
1165
1166   if (rule->flags & BUS_MATCH_PATH)
1167     {
1168       const char *path;
1169
1170       _dbus_assert (rule->path != NULL);
1171
1172       path = dbus_message_get_path (message);
1173       if (path == NULL)
1174         return FALSE;
1175
1176       if (strcmp (path, rule->path) != 0)
1177         return FALSE;
1178     }
1179
1180   return TRUE;
1181 }
1182
1183 dbus_bool_t
1184 bus_matchmaker_get_recipients (BusMatchmaker   *matchmaker,
1185                                BusConnections  *connections,
1186                                DBusConnection  *sender,
1187                                DBusConnection  *addressed_recipient,
1188                                DBusMessage     *message,
1189                                DBusList       **recipients_p)
1190 {
1191   /* FIXME for now this is a wholly unoptimized linear search */
1192   /* Guessing the important optimization is to skip the signal-related
1193    * match lists when processing method call and exception messages.
1194    * So separate match rule lists for signals?
1195    */
1196   
1197   DBusList *link;
1198
1199   _dbus_assert (*recipients_p == NULL);
1200
1201   /* This avoids sending same message to the same connection twice.
1202    * Purpose of the stamp instead of a bool is to avoid iterating over
1203    * all connections resetting the bool each time.
1204    */
1205   bus_connections_increment_stamp (connections);
1206
1207   /* addressed_recipient is already receiving the message, don't add to list.
1208    * NULL addressed_recipient means either bus driver, or this is a signal
1209    * and thus lacks a specific addressed_recipient.
1210    */
1211   if (addressed_recipient != NULL)
1212     bus_connection_mark_stamp (addressed_recipient);
1213
1214   link = _dbus_list_get_first_link (&matchmaker->all_rules);
1215   while (link != NULL)
1216     {
1217       BusMatchRule *rule;
1218
1219       rule = link->data;
1220
1221 #ifdef DBUS_ENABLE_VERBOSE_MODE
1222       {
1223         char *s = match_rule_to_string (rule);
1224         
1225         _dbus_verbose ("Checking whether message matches rule %s for connection %p\n",
1226                        s, rule->matches_go_to);
1227         dbus_free (s);
1228       }
1229 #endif
1230       
1231       if (match_rule_matches (rule, connections,
1232                               sender, addressed_recipient, message))
1233         {
1234           _dbus_verbose ("Rule matched\n");
1235           
1236           /* Append to the list if we haven't already */
1237           if (bus_connection_mark_stamp (rule->matches_go_to))
1238             {
1239               if (!_dbus_list_append (recipients_p, rule->matches_go_to))
1240                 goto nomem;
1241             }
1242 #ifdef DBUS_ENABLE_VERBOSE_MODE
1243           else
1244             {
1245               _dbus_verbose ("Connection already receiving this message, so not adding again\n");
1246             }
1247 #endif /* DBUS_ENABLE_VERBOSE_MODE */
1248         }
1249
1250       link = _dbus_list_get_next_link (&matchmaker->all_rules, link);
1251     }
1252
1253   return TRUE;
1254
1255  nomem:
1256   _dbus_list_clear (recipients_p);
1257   return FALSE;
1258 }
1259
1260 #ifdef DBUS_BUILD_TESTS
1261 #include "test.h"
1262 #include <stdlib.h>
1263
1264 static BusMatchRule*
1265 check_parse (dbus_bool_t should_succeed,
1266              const char *text)
1267 {
1268   BusMatchRule *rule;
1269   DBusString str;
1270   DBusError error;
1271
1272   dbus_error_init (&error);
1273
1274   _dbus_string_init_const (&str, text);
1275   
1276   rule = bus_match_rule_parse (NULL, &str, &error);
1277   if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
1278     {
1279       dbus_error_free (&error);
1280       return NULL;
1281     }
1282
1283   if (should_succeed && rule == NULL)
1284     {
1285       _dbus_warn ("Failed to parse: %s: %s: \"%s\"\n",
1286                   error.name, error.message,
1287                   _dbus_string_get_const_data (&str));
1288       exit (1);
1289     }
1290
1291   if (!should_succeed && rule != NULL)
1292     {
1293       _dbus_warn ("Failed to fail to parse: \"%s\"\n",
1294                   _dbus_string_get_const_data (&str));
1295       exit (1);
1296     }
1297
1298   dbus_error_free (&error);
1299
1300   return rule;
1301 }
1302
1303 static void
1304 assert_large_rule (BusMatchRule *rule)
1305 {
1306   _dbus_assert (rule->flags & BUS_MATCH_MESSAGE_TYPE);
1307   _dbus_assert (rule->flags & BUS_MATCH_SENDER);
1308   _dbus_assert (rule->flags & BUS_MATCH_INTERFACE);
1309   _dbus_assert (rule->flags & BUS_MATCH_MEMBER);
1310   _dbus_assert (rule->flags & BUS_MATCH_DESTINATION);
1311   _dbus_assert (rule->flags & BUS_MATCH_PATH);
1312
1313   _dbus_assert (rule->message_type == DBUS_MESSAGE_TYPE_SIGNAL);
1314   _dbus_assert (rule->interface != NULL);
1315   _dbus_assert (rule->member != NULL);
1316   _dbus_assert (rule->sender != NULL);
1317   _dbus_assert (rule->destination != NULL);
1318   _dbus_assert (rule->path != NULL);
1319
1320   _dbus_assert (strcmp (rule->interface, "org.freedesktop.DBusInterface") == 0);
1321   _dbus_assert (strcmp (rule->sender, "org.freedesktop.DBusSender") == 0);
1322   _dbus_assert (strcmp (rule->member, "Foo") == 0);
1323   _dbus_assert (strcmp (rule->path, "/bar/foo") == 0);
1324   _dbus_assert (strcmp (rule->destination, ":452345.34") == 0);
1325 }
1326
1327 static dbus_bool_t
1328 test_parsing (void *data)
1329 {
1330   BusMatchRule *rule;
1331
1332   rule = check_parse (TRUE, "type='signal',sender='org.freedesktop.DBusSender',interface='org.freedesktop.DBusInterface',member='Foo',path='/bar/foo',destination=':452345.34'");
1333   if (rule != NULL)
1334     {
1335       assert_large_rule (rule);
1336       bus_match_rule_unref (rule);
1337     }
1338
1339   /* With extra whitespace and useless quotes */
1340   rule = check_parse (TRUE, "    type='signal',  \tsender='org.freedes''ktop.DBusSender',   interface='org.freedesktop.DBusInterface''''', \tmember='Foo',path='/bar/foo',destination=':452345.34'''''");
1341   if (rule != NULL)
1342     {
1343       assert_large_rule (rule);
1344       bus_match_rule_unref (rule);
1345     }
1346
1347
1348   /* A simple signal connection */
1349   rule = check_parse (TRUE, "type='signal',path='/foo',interface='org.Bar'");
1350   if (rule != NULL)
1351     {
1352       _dbus_assert (rule->flags & BUS_MATCH_MESSAGE_TYPE);
1353       _dbus_assert (rule->flags & BUS_MATCH_INTERFACE);
1354       _dbus_assert (rule->flags & BUS_MATCH_PATH);
1355
1356       _dbus_assert (rule->message_type == DBUS_MESSAGE_TYPE_SIGNAL);
1357       _dbus_assert (rule->interface != NULL);
1358       _dbus_assert (rule->path != NULL);
1359
1360       _dbus_assert (strcmp (rule->interface, "org.Bar") == 0);
1361       _dbus_assert (strcmp (rule->path, "/foo") == 0);
1362   
1363       bus_match_rule_unref (rule);
1364     }
1365
1366   /* Reject duplicates */
1367   rule = check_parse (FALSE, "type='signal',type='method_call'");
1368   _dbus_assert (rule == NULL);
1369
1370   /* Reject broken keys */
1371   rule = check_parse (FALSE, "blah='signal'");
1372   _dbus_assert (rule == NULL);
1373
1374   /* Reject broken valuess */
1375   rule = check_parse (FALSE, "type='chouin'");
1376   _dbus_assert (rule == NULL);
1377   rule = check_parse (FALSE, "interface='abc@def++'");
1378   _dbus_assert (rule == NULL);
1379   rule = check_parse (FALSE, "service='youpi'");
1380   _dbus_assert (rule == NULL);
1381
1382   /* Allow empty rule */
1383   rule = check_parse (TRUE, "");
1384   if (rule != NULL)
1385     {
1386       _dbus_assert (rule->flags == 0);
1387       
1388       bus_match_rule_unref (rule);
1389     }
1390
1391   /* All-whitespace rule is the same as empty */
1392   rule = check_parse (TRUE, "    \t");
1393   if (rule != NULL)
1394     {
1395       _dbus_assert (rule->flags == 0);
1396       
1397       bus_match_rule_unref (rule);
1398     }
1399
1400   /* But with non-whitespace chars and no =value, it's not OK */
1401   rule = check_parse (FALSE, "type");
1402   _dbus_assert (rule == NULL);
1403
1404   return TRUE;
1405 }
1406
1407 dbus_bool_t
1408 bus_signals_test (const DBusString *test_data_dir)
1409 {
1410   BusMatchmaker *matchmaker;
1411
1412   matchmaker = bus_matchmaker_new ();
1413   bus_matchmaker_ref (matchmaker);
1414   bus_matchmaker_unref (matchmaker);
1415   bus_matchmaker_unref (matchmaker);
1416
1417   if (!_dbus_test_oom_handling ("parsing match rules", test_parsing, NULL))
1418     _dbus_assert_not_reached ("Parsing match rules test failed");
1419   
1420   return TRUE;
1421 }
1422
1423 #endif /* DBUS_BUILD_TESTS */
1424