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