sl@0: /* -*- mode: C; c-file-style: "gnu" -*- */
sl@0: /* signals.c  Bus signal connection implementation
sl@0:  *
sl@0:  * Copyright (C) 2003, 2005  Red Hat, Inc.
sl@0:  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.
sl@0:  * Licensed under the Academic Free License version 2.1
sl@0:  *
sl@0:  * This program is free software; you can redistribute it and/or modify
sl@0:  * it under the terms of the GNU General Public License as published by
sl@0:  * the Free Software Foundation; either version 2 of the License, or
sl@0:  * (at your option) any later version.
sl@0:  *
sl@0:  * This program is distributed in the hope that it will be useful,
sl@0:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
sl@0:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
sl@0:  * GNU General Public License for more details.
sl@0:  *
sl@0:  * You should have received a copy of the GNU General Public License
sl@0:  * along with this program; if not, write to the Free Software
sl@0:  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
sl@0:  *
sl@0:  */
sl@0: #include "signals.h"
sl@0: #include "services.h"
sl@0: #include "utils.h"
sl@0: #ifndef __SYMBIAN32__
sl@0: #include <dbus/dbus-marshal-validate.h>
sl@0: #else
sl@0: #include "dbus-marshal-validate.h"
sl@0: #include "config.h"
sl@0: #endif //__SYMBIAN32__
sl@0: 
sl@0: struct BusMatchRule
sl@0: {
sl@0:   int refcount;       /**< reference count */
sl@0: 
sl@0:   DBusConnection *matches_go_to; /**< Owner of the rule */
sl@0: 
sl@0:   unsigned int flags; /**< BusMatchFlags */
sl@0: 
sl@0:   int   message_type;
sl@0:   char *interface;
sl@0:   char *member;
sl@0:   char *sender;
sl@0:   char *destination;
sl@0:   char *path;
sl@0: 
sl@0:   char **args;
sl@0:   int args_len;
sl@0: };
sl@0: 
sl@0: BusMatchRule*
sl@0: bus_match_rule_new (DBusConnection *matches_go_to)
sl@0: {
sl@0:   BusMatchRule *rule;
sl@0: 
sl@0:   rule = dbus_new0 (BusMatchRule, 1);
sl@0:   if (rule == NULL)
sl@0:     return NULL;
sl@0: 
sl@0:   rule->refcount = 1;
sl@0:   rule->matches_go_to = matches_go_to;
sl@0: 
sl@0: #ifndef DBUS_BUILD_TESTS
sl@0:   _dbus_assert (rule->matches_go_to != NULL);
sl@0: #endif
sl@0:   
sl@0:   return rule;
sl@0: }
sl@0: 
sl@0: BusMatchRule *
sl@0: bus_match_rule_ref (BusMatchRule *rule)
sl@0: {
sl@0:   _dbus_assert (rule->refcount > 0);
sl@0: 
sl@0:   rule->refcount += 1;
sl@0: 
sl@0:   return rule;
sl@0: }
sl@0: 
sl@0: void
sl@0: bus_match_rule_unref (BusMatchRule *rule)
sl@0: {
sl@0:   _dbus_assert (rule->refcount > 0);
sl@0: 
sl@0:   rule->refcount -= 1;
sl@0:   if (rule->refcount == 0)
sl@0:     {
sl@0:       dbus_free (rule->interface);
sl@0:       dbus_free (rule->member);
sl@0:       dbus_free (rule->sender);
sl@0:       dbus_free (rule->destination);
sl@0:       dbus_free (rule->path);
sl@0: 
sl@0:       /* can't use dbus_free_string_array() since there
sl@0:        * are embedded NULL
sl@0:        */
sl@0:       if (rule->args)
sl@0:         {
sl@0:           int i;
sl@0: 
sl@0:           i = 0;
sl@0:           while (i < rule->args_len)
sl@0:             {
sl@0:               if (rule->args[i])
sl@0:                 dbus_free (rule->args[i]);
sl@0:               ++i;
sl@0:             }
sl@0: 
sl@0:           dbus_free (rule->args);
sl@0:         }
sl@0:       
sl@0:       dbus_free (rule);
sl@0:     }
sl@0: }
sl@0: 
sl@0: #ifdef DBUS_ENABLE_VERBOSE_MODE
sl@0: /* Note this function does not do escaping, so it's only
sl@0:  * good for debug spew at the moment
sl@0:  */
sl@0: static char*
sl@0: match_rule_to_string (BusMatchRule *rule)
sl@0: {
sl@0:   DBusString str;
sl@0:   char *ret;
sl@0:   
sl@0:   if (!_dbus_string_init (&str))
sl@0:     {
sl@0:       char *s;
sl@0:       while ((s = _dbus_strdup ("nomem")) == NULL)
sl@0:         ; /* only OK for debug spew... */
sl@0:       return s;
sl@0:     }
sl@0:   
sl@0:   if (rule->flags & BUS_MATCH_MESSAGE_TYPE)
sl@0:     {
sl@0:       /* FIXME make type readable */
sl@0:       if (!_dbus_string_append_printf (&str, "type='%d'", rule->message_type))
sl@0:         goto nomem;
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_INTERFACE)
sl@0:     {
sl@0:       if (_dbus_string_get_length (&str) > 0)
sl@0:         {
sl@0:           if (!_dbus_string_append (&str, ","))
sl@0:             goto nomem;
sl@0:         }
sl@0:       
sl@0:       if (!_dbus_string_append_printf (&str, "interface='%s'", rule->interface))
sl@0:         goto nomem;
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_MEMBER)
sl@0:     {
sl@0:       if (_dbus_string_get_length (&str) > 0)
sl@0:         {
sl@0:           if (!_dbus_string_append (&str, ","))
sl@0:             goto nomem;
sl@0:         }
sl@0:       
sl@0:       if (!_dbus_string_append_printf (&str, "member='%s'", rule->member))
sl@0:         goto nomem;
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_PATH)
sl@0:     {
sl@0:       if (_dbus_string_get_length (&str) > 0)
sl@0:         {
sl@0:           if (!_dbus_string_append (&str, ","))
sl@0:             goto nomem;
sl@0:         }
sl@0:       
sl@0:       if (!_dbus_string_append_printf (&str, "path='%s'", rule->path))
sl@0:         goto nomem;
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_SENDER)
sl@0:     {
sl@0:       if (_dbus_string_get_length (&str) > 0)
sl@0:         {
sl@0:           if (!_dbus_string_append (&str, ","))
sl@0:             goto nomem;
sl@0:         }
sl@0:       
sl@0:       if (!_dbus_string_append_printf (&str, "sender='%s'", rule->sender))
sl@0:         goto nomem;
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_DESTINATION)
sl@0:     {
sl@0:       if (_dbus_string_get_length (&str) > 0)
sl@0:         {
sl@0:           if (!_dbus_string_append (&str, ","))
sl@0:             goto nomem;
sl@0:         }
sl@0:       
sl@0:       if (!_dbus_string_append_printf (&str, "destination='%s'", rule->destination))
sl@0:         goto nomem;
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_ARGS)
sl@0:     {
sl@0:       int i;
sl@0:       
sl@0:       _dbus_assert (rule->args != NULL);
sl@0: 
sl@0:       i = 0;
sl@0:       while (i < rule->args_len)
sl@0:         {
sl@0:           if (rule->args[i] != NULL)
sl@0:             {
sl@0:               if (_dbus_string_get_length (&str) > 0)
sl@0:                 {
sl@0:                   if (!_dbus_string_append (&str, ","))
sl@0:                     goto nomem;
sl@0:                 }
sl@0:               
sl@0:               if (!_dbus_string_append_printf (&str,
sl@0:                                                "arg%d='%s'",
sl@0:                                                i,
sl@0:                                                rule->args[i]))
sl@0:                 goto nomem;
sl@0:             }
sl@0:           
sl@0:           ++i;
sl@0:         }
sl@0:     }
sl@0:   
sl@0:   if (!_dbus_string_steal_data (&str, &ret))
sl@0:     goto nomem;
sl@0: 
sl@0:   _dbus_string_free (&str);
sl@0:   return ret;
sl@0:   
sl@0:  nomem:
sl@0:   _dbus_string_free (&str);
sl@0:   {
sl@0:     char *s;
sl@0:     while ((s = _dbus_strdup ("nomem")) == NULL)
sl@0:       ;  /* only OK for debug spew... */
sl@0:     return s;
sl@0:   }
sl@0: }
sl@0: #endif /* DBUS_ENABLE_VERBOSE_MODE */
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_match_rule_set_message_type (BusMatchRule *rule,
sl@0:                                  int           type)
sl@0: {
sl@0:   rule->flags |= BUS_MATCH_MESSAGE_TYPE;
sl@0: 
sl@0:   rule->message_type = type;
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_match_rule_set_interface (BusMatchRule *rule,
sl@0:                               const char   *interface)
sl@0: {
sl@0:   char *new;
sl@0: 
sl@0:   _dbus_assert (interface != NULL);
sl@0: 
sl@0:   new = _dbus_strdup (interface);
sl@0:   if (new == NULL)
sl@0:     return FALSE;
sl@0: 
sl@0:   rule->flags |= BUS_MATCH_INTERFACE;
sl@0:   dbus_free (rule->interface);
sl@0:   rule->interface = new;
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_match_rule_set_member (BusMatchRule *rule,
sl@0:                            const char   *member)
sl@0: {
sl@0:   char *new;
sl@0: 
sl@0:   _dbus_assert (member != NULL);
sl@0: 
sl@0:   new = _dbus_strdup (member);
sl@0:   if (new == NULL)
sl@0:     return FALSE;
sl@0: 
sl@0:   rule->flags |= BUS_MATCH_MEMBER;
sl@0:   dbus_free (rule->member);
sl@0:   rule->member = new;
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_match_rule_set_sender (BusMatchRule *rule,
sl@0:                            const char   *sender)
sl@0: {
sl@0:   char *new;
sl@0: 
sl@0:   _dbus_assert (sender != NULL);
sl@0: 
sl@0:   new = _dbus_strdup (sender);
sl@0:   if (new == NULL)
sl@0:     return FALSE;
sl@0: 
sl@0:   rule->flags |= BUS_MATCH_SENDER;
sl@0:   dbus_free (rule->sender);
sl@0:   rule->sender = new;
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_match_rule_set_destination (BusMatchRule *rule,
sl@0:                                 const char   *destination)
sl@0: {
sl@0:   char *new;
sl@0: 
sl@0:   _dbus_assert (destination != NULL);
sl@0: 
sl@0:   new = _dbus_strdup (destination);
sl@0:   if (new == NULL)
sl@0:     return FALSE;
sl@0: 
sl@0:   rule->flags |= BUS_MATCH_DESTINATION;
sl@0:   dbus_free (rule->destination);
sl@0:   rule->destination = new;
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_match_rule_set_path (BusMatchRule *rule,
sl@0:                          const char   *path)
sl@0: {
sl@0:   char *new;
sl@0: 
sl@0:   _dbus_assert (path != NULL);
sl@0: 
sl@0:   new = _dbus_strdup (path);
sl@0:   if (new == NULL)
sl@0:     return FALSE;
sl@0: 
sl@0:   rule->flags |= BUS_MATCH_PATH;
sl@0:   dbus_free (rule->path);
sl@0:   rule->path = new;
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_match_rule_set_arg (BusMatchRule *rule,
sl@0:                         int           arg,
sl@0:                         const char   *value)
sl@0: {
sl@0:   char *new;
sl@0: 
sl@0:   _dbus_assert (value != NULL);
sl@0: 
sl@0:   new = _dbus_strdup (value);
sl@0:   if (new == NULL)
sl@0:     return FALSE;
sl@0: 
sl@0:   /* args_len is the number of args not including null termination
sl@0:    * in the char**
sl@0:    */
sl@0:   if (arg >= rule->args_len)
sl@0:     {
sl@0:       char **new_args;
sl@0:       int new_args_len;
sl@0:       int i;
sl@0: 
sl@0:       new_args_len = arg + 1;
sl@0: 
sl@0:       /* add another + 1 here for null termination */
sl@0:       new_args = dbus_realloc (rule->args,
sl@0:                                sizeof(rule->args[0]) * (new_args_len + 1));
sl@0:       if (new_args == NULL)
sl@0:         {
sl@0:           dbus_free (new);
sl@0:           return FALSE;
sl@0:         }
sl@0: 
sl@0:       /* NULL the new slots */
sl@0:       i = rule->args_len;
sl@0:       while (i <= new_args_len) /* <= for null termination */
sl@0:         {
sl@0:           new_args[i] = NULL;
sl@0:           ++i;
sl@0:         }
sl@0:       
sl@0:       rule->args = new_args;
sl@0:       rule->args_len = new_args_len;
sl@0:     }
sl@0: 
sl@0:   rule->flags |= BUS_MATCH_ARGS;
sl@0: 
sl@0:   dbus_free (rule->args[arg]);
sl@0:   rule->args[arg] = new;
sl@0: 
sl@0:   /* NULL termination didn't get busted */
sl@0:   _dbus_assert (rule->args[rule->args_len] == NULL);
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: #define ISWHITE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r'))
sl@0: 
sl@0: static dbus_bool_t
sl@0: find_key (const DBusString *str,
sl@0:           int               start,
sl@0:           DBusString       *key,
sl@0:           int              *value_pos,
sl@0:           DBusError        *error)
sl@0: {
sl@0:   const char *p;
sl@0:   const char *s;
sl@0:   const char *key_start;
sl@0:   const char *key_end;
sl@0: 
sl@0:   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
sl@0:   
sl@0:   s = _dbus_string_get_const_data (str);
sl@0: 
sl@0:   p = s + start;
sl@0: 
sl@0:   while (*p && ISWHITE (*p))
sl@0:     ++p;
sl@0: 
sl@0:   key_start = p;
sl@0: 
sl@0:   while (*p && *p != '=' && !ISWHITE (*p))
sl@0:     ++p;
sl@0: 
sl@0:   key_end = p;
sl@0: 
sl@0:   while (*p && ISWHITE (*p))
sl@0:     ++p;
sl@0:   
sl@0:   if (key_start == key_end)
sl@0:     {
sl@0:       /* Empty match rules or trailing whitespace are OK */
sl@0:       *value_pos = p - s;
sl@0:       return TRUE;
sl@0:     }
sl@0: 
sl@0:   if (*p != '=')
sl@0:     {
sl@0:       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                       "Match rule has a key with no subsequent '=' character");
sl@0:       return FALSE;
sl@0:     }
sl@0:   ++p;
sl@0:   
sl@0:   if (!_dbus_string_append_len (key, key_start, key_end - key_start))
sl@0:     {
sl@0:       BUS_SET_OOM (error);
sl@0:       return FALSE;
sl@0:     }
sl@0: 
sl@0:   *value_pos = p - s;
sl@0:   
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: static dbus_bool_t
sl@0: find_value (const DBusString *str,
sl@0:             int               start,
sl@0:             const char       *key,
sl@0:             DBusString       *value,
sl@0:             int              *value_end,
sl@0:             DBusError        *error)
sl@0: {
sl@0:   const char *p;
sl@0:   const char *s;
sl@0:   char quote_char;
sl@0:   int orig_len;
sl@0: 
sl@0:   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
sl@0:   
sl@0:   orig_len = _dbus_string_get_length (value);
sl@0:   
sl@0:   s = _dbus_string_get_const_data (str);
sl@0: 
sl@0:   p = s + start;
sl@0: 
sl@0:   quote_char = '\0';
sl@0: 
sl@0:   while (*p)
sl@0:     {
sl@0:       if (quote_char == '\0')
sl@0:         {
sl@0:           switch (*p)
sl@0:             {
sl@0:             case '\0':
sl@0:               goto done;
sl@0: 
sl@0:             case '\'':
sl@0:               quote_char = '\'';
sl@0:               goto next;
sl@0:               
sl@0:             case ',':
sl@0:               ++p;
sl@0:               goto done;
sl@0: 
sl@0:             case '\\':
sl@0:               quote_char = '\\';
sl@0:               goto next;
sl@0:               
sl@0:             default:
sl@0:               if (!_dbus_string_append_byte (value, *p))
sl@0:                 {
sl@0:                   BUS_SET_OOM (error);
sl@0:                   goto failed;
sl@0:                 }
sl@0:             }
sl@0:         }
sl@0:       else if (quote_char == '\\')
sl@0:         {
sl@0:           /* \ only counts as an escape if escaping a quote mark */
sl@0:           if (*p != '\'')
sl@0:             {
sl@0:               if (!_dbus_string_append_byte (value, '\\'))
sl@0:                 {
sl@0:                   BUS_SET_OOM (error);
sl@0:                   goto failed;
sl@0:                 }
sl@0:             }
sl@0: 
sl@0:           if (!_dbus_string_append_byte (value, *p))
sl@0:             {
sl@0:               BUS_SET_OOM (error);
sl@0:               goto failed;
sl@0:             }
sl@0:           
sl@0:           quote_char = '\0';
sl@0:         }
sl@0:       else
sl@0:         {
sl@0:           _dbus_assert (quote_char == '\'');
sl@0: 
sl@0:           if (*p == '\'')
sl@0:             {
sl@0:               quote_char = '\0';
sl@0:             }
sl@0:           else
sl@0:             {
sl@0:               if (!_dbus_string_append_byte (value, *p))
sl@0:                 {
sl@0:                   BUS_SET_OOM (error);
sl@0:                   goto failed;
sl@0:                 }
sl@0:             }
sl@0:         }
sl@0: 
sl@0:     next:
sl@0:       ++p;
sl@0:     }
sl@0: 
sl@0:  done:
sl@0: 
sl@0:   if (quote_char == '\\')
sl@0:     {
sl@0:       if (!_dbus_string_append_byte (value, '\\'))
sl@0:         {
sl@0:           BUS_SET_OOM (error);
sl@0:           goto failed;
sl@0:         }
sl@0:     }
sl@0:   else if (quote_char == '\'')
sl@0:     {
sl@0:       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                       "Unbalanced quotation marks in match rule");
sl@0:       goto failed;
sl@0:     }
sl@0:   else
sl@0:     _dbus_assert (quote_char == '\0');
sl@0: 
sl@0:   /* Zero-length values are allowed */
sl@0:   
sl@0:   *value_end = p - s;
sl@0:   
sl@0:   return TRUE;
sl@0: 
sl@0:  failed:
sl@0:   _DBUS_ASSERT_ERROR_IS_SET (error);
sl@0:   _dbus_string_set_length (value, orig_len);
sl@0:   return FALSE;
sl@0: }
sl@0: 
sl@0: /* duplicates aren't allowed so the real legitimate max is only 6 or
sl@0:  * so. Leaving extra so we don't have to bother to update it.
sl@0:  * FIXME this is sort of busted now with arg matching, but we let
sl@0:  * you match on up to 10 args for now
sl@0:  */
sl@0: #define MAX_RULE_TOKENS 16
sl@0: 
sl@0: /* this is slightly too high level to be termed a "token"
sl@0:  * but let's not be pedantic.
sl@0:  */
sl@0: typedef struct
sl@0: {
sl@0:   char *key;
sl@0:   char *value;
sl@0: } RuleToken;
sl@0: 
sl@0: static dbus_bool_t
sl@0: tokenize_rule (const DBusString *rule_text,
sl@0:                RuleToken         tokens[MAX_RULE_TOKENS],
sl@0:                DBusError        *error) 
sl@0: {
sl@0:   int i;
sl@0:   int pos;
sl@0:   DBusString key;
sl@0:   DBusString value;
sl@0:   dbus_bool_t retval;
sl@0: 
sl@0:   retval = FALSE;
sl@0:   
sl@0:   if (!_dbus_string_init (&key))
sl@0:     {
sl@0:       BUS_SET_OOM (error);
sl@0:       return FALSE;
sl@0:     }
sl@0: 
sl@0:   if (!_dbus_string_init (&value))
sl@0:     {
sl@0:       _dbus_string_free (&key);
sl@0:       BUS_SET_OOM (error);
sl@0:       return FALSE;
sl@0:     }
sl@0: 
sl@0:   i = 0;
sl@0:   pos = 0;
sl@0:   while (i < MAX_RULE_TOKENS &&
sl@0:          pos < _dbus_string_get_length (rule_text))
sl@0:     {
sl@0:       _dbus_assert (tokens[i].key == NULL);
sl@0:       _dbus_assert (tokens[i].value == NULL);
sl@0: 
sl@0:       if (!find_key (rule_text, pos, &key, &pos, error))
sl@0:         goto out;
sl@0: 
sl@0:       if (_dbus_string_get_length (&key) == 0)
sl@0:         goto next;
sl@0:       
sl@0:       if (!_dbus_string_steal_data (&key, &tokens[i].key))
sl@0:         {
sl@0:           BUS_SET_OOM (error);
sl@0:           goto out;
sl@0:         }
sl@0: 
sl@0:       if (!find_value (rule_text, pos, tokens[i].key, &value, &pos, error))
sl@0:         goto out;
sl@0: 
sl@0:       if (!_dbus_string_steal_data (&value, &tokens[i].value))
sl@0:         {
sl@0:           BUS_SET_OOM (error);
sl@0:           goto out;
sl@0:         }
sl@0: 
sl@0:     next:
sl@0:       ++i;
sl@0:     }
sl@0: 
sl@0:   retval = TRUE;
sl@0:   
sl@0:  out:
sl@0:   if (!retval)
sl@0:     {
sl@0:       i = 0;
sl@0:       while (tokens[i].key || tokens[i].value)
sl@0:         {
sl@0:           dbus_free (tokens[i].key);
sl@0:           dbus_free (tokens[i].value);
sl@0:           tokens[i].key = NULL;
sl@0:           tokens[i].value = NULL;
sl@0:           ++i;
sl@0:         }
sl@0:     }
sl@0:   
sl@0:   _dbus_string_free (&key);
sl@0:   _dbus_string_free (&value);
sl@0:   
sl@0:   return retval;
sl@0: }
sl@0: 
sl@0: static dbus_bool_t
sl@0: bus_match_rule_parse_arg_match (BusMatchRule     *rule,
sl@0:                                 const char       *key,
sl@0:                                 const DBusString *value,
sl@0:                                 DBusError        *error)
sl@0: {
sl@0:   DBusString key_str;
sl@0:   unsigned long arg;
sl@0:   int end;
sl@0: 
sl@0:   /* For now, arg0='foo' always implies that 'foo' is a
sl@0:    * DBUS_TYPE_STRING. Someday we could add an arg0type='int32' thing
sl@0:    * if we wanted, which would specify another type, in which case
sl@0:    * arg0='5' would have the 5 parsed as an int rather than string.
sl@0:    */
sl@0:   
sl@0:   /* First we need to parse arg0 = 0, arg27 = 27 */
sl@0: 
sl@0:   _dbus_string_init_const (&key_str, key);
sl@0: 
sl@0:   if (_dbus_string_get_length (&key_str) < 4)
sl@0:     {
sl@0:       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                       "Key '%s' in match rule starts with 'arg' but lacks an arg number. Should be 'arg0' or 'arg7' for example.\n", key);
sl@0:       goto failed;
sl@0:     }
sl@0: 
sl@0:   if (!_dbus_string_parse_uint (&key_str, 3, &arg, &end) ||
sl@0:       end != _dbus_string_get_length (&key_str))
sl@0:     {
sl@0:       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                       "Key '%s' in match rule starts with 'arg' but could not parse arg number. Should be 'arg0' or 'arg7' for example.\n", key);
sl@0:       goto failed;
sl@0:     }
sl@0: 
sl@0:   /* If we didn't check this we could allocate a huge amount of RAM */
sl@0:   if (arg > DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER)
sl@0:     {
sl@0:       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                       "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);
sl@0:       goto failed;
sl@0:     }
sl@0:   
sl@0:   if ((rule->flags & BUS_MATCH_ARGS) &&
sl@0:       rule->args_len > (int) arg &&
sl@0:       rule->args[arg] != NULL)
sl@0:     {
sl@0:       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                       "Key '%s' specified twice in match rule\n", key);
sl@0:       goto failed;
sl@0:     }
sl@0:   
sl@0:   if (!bus_match_rule_set_arg (rule, arg,
sl@0:                                _dbus_string_get_const_data (value)))
sl@0:     {
sl@0:       BUS_SET_OOM (error);
sl@0:       goto failed;
sl@0:     }
sl@0: 
sl@0:   return TRUE;
sl@0: 
sl@0:  failed:
sl@0:   _DBUS_ASSERT_ERROR_IS_SET (error);
sl@0:   return FALSE;
sl@0: }
sl@0: 
sl@0: /*
sl@0:  * The format is comma-separated with strings quoted with single quotes
sl@0:  * as for the shell (to escape a literal single quote, use '\'').
sl@0:  *
sl@0:  * type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='Foo',
sl@0:  * path='/bar/foo',destination=':452345.34'
sl@0:  *
sl@0:  */
sl@0: BusMatchRule*
sl@0: bus_match_rule_parse (DBusConnection   *matches_go_to,
sl@0:                       const DBusString *rule_text,
sl@0:                       DBusError        *error)
sl@0: {
sl@0:   BusMatchRule *rule;
sl@0:   RuleToken tokens[MAX_RULE_TOKENS+1]; /* NULL termination + 1 */
sl@0:   int i;
sl@0:   
sl@0:   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
sl@0: 
sl@0:   if (_dbus_string_get_length (rule_text) > DBUS_MAXIMUM_MATCH_RULE_LENGTH)
sl@0:     {
sl@0:       dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,
sl@0:                       "Match rule text is %d bytes, maximum is %d",
sl@0:                       _dbus_string_get_length (rule_text),
sl@0:                       DBUS_MAXIMUM_MATCH_RULE_LENGTH);
sl@0:       return NULL;
sl@0:     }
sl@0:   
sl@0:   memset (tokens, '\0', sizeof (tokens));
sl@0:   
sl@0:   rule = bus_match_rule_new (matches_go_to);
sl@0:   if (rule == NULL)
sl@0:     {
sl@0:       BUS_SET_OOM (error);
sl@0:       goto failed;
sl@0:     }
sl@0:   
sl@0:   if (!tokenize_rule (rule_text, tokens, error))
sl@0:     goto failed;
sl@0:   
sl@0:   i = 0;
sl@0:   while (tokens[i].key != NULL)
sl@0:     {
sl@0:       DBusString tmp_str;
sl@0:       int len;
sl@0:       const char *key = tokens[i].key;
sl@0:       const char *value = tokens[i].value;
sl@0:       
sl@0:       _dbus_string_init_const (&tmp_str, value);
sl@0:       len = _dbus_string_get_length (&tmp_str);
sl@0: 
sl@0:       if (strcmp (key, "type") == 0)
sl@0:         {
sl@0:           int t;
sl@0: 
sl@0:           if (rule->flags & BUS_MATCH_MESSAGE_TYPE)
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Key %s specified twice in match rule\n", key);
sl@0:               goto failed;
sl@0:             }
sl@0:           
sl@0:           t = dbus_message_type_from_string (value);
sl@0:           
sl@0:           if (t == DBUS_MESSAGE_TYPE_INVALID)
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Invalid message type (%s) in match rule\n", value);
sl@0:               goto failed;
sl@0:             }
sl@0: 
sl@0:           if (!bus_match_rule_set_message_type (rule, t))
sl@0:             {
sl@0:               BUS_SET_OOM (error);
sl@0:               goto failed;
sl@0:             }
sl@0:         }
sl@0:       else if (strcmp (key, "sender") == 0)
sl@0:         {
sl@0:           if (rule->flags & BUS_MATCH_SENDER)
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Key %s specified twice in match rule\n", key);
sl@0:               goto failed;
sl@0:             }
sl@0: 
sl@0:           if (!_dbus_validate_bus_name (&tmp_str, 0, len))
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Sender name '%s' is invalid\n", value);
sl@0:               goto failed;
sl@0:             }
sl@0: 
sl@0:           if (!bus_match_rule_set_sender (rule, value))
sl@0:             {
sl@0:               BUS_SET_OOM (error);
sl@0:               goto failed;
sl@0:             }
sl@0:         }
sl@0:       else if (strcmp (key, "interface") == 0)
sl@0:         {
sl@0:           if (rule->flags & BUS_MATCH_INTERFACE)
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Key %s specified twice in match rule\n", key);
sl@0:               goto failed;
sl@0:             }
sl@0: 
sl@0:           if (!_dbus_validate_interface (&tmp_str, 0, len))
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Interface name '%s' is invalid\n", value);
sl@0:               goto failed;
sl@0:             }
sl@0: 
sl@0:           if (!bus_match_rule_set_interface (rule, value))
sl@0:             {
sl@0:               BUS_SET_OOM (error);
sl@0:               goto failed;
sl@0:             }
sl@0:         }
sl@0:       else if (strcmp (key, "member") == 0)
sl@0:         {
sl@0:           if (rule->flags & BUS_MATCH_MEMBER)
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Key %s specified twice in match rule\n", key);
sl@0:               goto failed;
sl@0:             }
sl@0: 
sl@0:           if (!_dbus_validate_member (&tmp_str, 0, len))
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Member name '%s' is invalid\n", value);
sl@0:               goto failed;
sl@0:             }
sl@0: 
sl@0:           if (!bus_match_rule_set_member (rule, value))
sl@0:             {
sl@0:               BUS_SET_OOM (error);
sl@0:               goto failed;
sl@0:             }
sl@0:         }
sl@0:       else if (strcmp (key, "path") == 0)
sl@0:         {
sl@0:           if (rule->flags & BUS_MATCH_PATH)
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Key %s specified twice in match rule\n", key);
sl@0:               goto failed;
sl@0:             }
sl@0: 
sl@0:           if (!_dbus_validate_path (&tmp_str, 0, len))
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Path '%s' is invalid\n", value);
sl@0:               goto failed;
sl@0:             }
sl@0: 
sl@0:           if (!bus_match_rule_set_path (rule, value))
sl@0:             {
sl@0:               BUS_SET_OOM (error);
sl@0:               goto failed;
sl@0:             }
sl@0:         }
sl@0:       else if (strcmp (key, "destination") == 0)
sl@0:         {
sl@0:           if (rule->flags & BUS_MATCH_DESTINATION)
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Key %s specified twice in match rule\n", key);
sl@0:               goto failed;
sl@0:             }
sl@0: 
sl@0:           if (!_dbus_validate_bus_name (&tmp_str, 0, len))
sl@0:             {
sl@0:               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                               "Destination name '%s' is invalid\n", value);
sl@0:               goto failed;
sl@0:             }
sl@0: 
sl@0:           if (!bus_match_rule_set_destination (rule, value))
sl@0:             {
sl@0:               BUS_SET_OOM (error);
sl@0:               goto failed;
sl@0:             }
sl@0:         }
sl@0:       else if (strncmp (key, "arg", 3) == 0)
sl@0:         {
sl@0:           if (!bus_match_rule_parse_arg_match (rule, key, &tmp_str, error))
sl@0:             goto failed;
sl@0:         }
sl@0:       else
sl@0:         {
sl@0:           dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,
sl@0:                           "Unknown key \"%s\" in match rule",
sl@0:                           key);
sl@0:           goto failed;
sl@0:         }
sl@0: 
sl@0:       ++i;
sl@0:     }
sl@0:   
sl@0: 
sl@0:   goto out;
sl@0:   
sl@0:  failed:
sl@0:   _DBUS_ASSERT_ERROR_IS_SET (error);
sl@0:   if (rule)
sl@0:     {
sl@0:       bus_match_rule_unref (rule);
sl@0:       rule = NULL;
sl@0:     }
sl@0: 
sl@0:  out:
sl@0:   
sl@0:   i = 0;
sl@0:   while (tokens[i].key || tokens[i].value)
sl@0:     {
sl@0:       _dbus_assert (i < MAX_RULE_TOKENS);
sl@0:       dbus_free (tokens[i].key);
sl@0:       dbus_free (tokens[i].value);
sl@0:       ++i;
sl@0:     }
sl@0:   
sl@0:   return rule;
sl@0: }
sl@0: 
sl@0: struct BusMatchmaker
sl@0: {
sl@0:   int refcount;
sl@0: 
sl@0:   DBusList *all_rules;
sl@0: };
sl@0: 
sl@0: BusMatchmaker*
sl@0: bus_matchmaker_new (void)
sl@0: {
sl@0:   BusMatchmaker *matchmaker;
sl@0: 
sl@0:   matchmaker = dbus_new0 (BusMatchmaker, 1);
sl@0:   if (matchmaker == NULL)
sl@0:     return NULL;
sl@0: 
sl@0:   matchmaker->refcount = 1;
sl@0:   
sl@0:   return matchmaker;
sl@0: }
sl@0: 
sl@0: BusMatchmaker *
sl@0: bus_matchmaker_ref (BusMatchmaker *matchmaker)
sl@0: {
sl@0:   _dbus_assert (matchmaker->refcount > 0);
sl@0: 
sl@0:   matchmaker->refcount += 1;
sl@0: 
sl@0:   return matchmaker;
sl@0: }
sl@0: 
sl@0: void
sl@0: bus_matchmaker_unref (BusMatchmaker *matchmaker)
sl@0: {
sl@0:   _dbus_assert (matchmaker->refcount > 0);
sl@0: 
sl@0:   matchmaker->refcount -= 1;
sl@0:   if (matchmaker->refcount == 0)
sl@0:     {
sl@0:       while (matchmaker->all_rules != NULL)
sl@0:         {
sl@0:           BusMatchRule *rule;
sl@0: 
sl@0:           rule = matchmaker->all_rules->data;
sl@0:           bus_match_rule_unref (rule);
sl@0:           _dbus_list_remove_link (&matchmaker->all_rules,
sl@0:                                   matchmaker->all_rules);
sl@0:         }
sl@0: 
sl@0:       dbus_free (matchmaker);
sl@0:     }
sl@0: }
sl@0: 
sl@0: /* The rule can't be modified after it's added. */
sl@0: dbus_bool_t
sl@0: bus_matchmaker_add_rule (BusMatchmaker   *matchmaker,
sl@0:                          BusMatchRule    *rule)
sl@0: {
sl@0:   _dbus_assert (bus_connection_is_active (rule->matches_go_to));
sl@0: 
sl@0:   if (!_dbus_list_append (&matchmaker->all_rules, rule))
sl@0:     return FALSE;
sl@0: 
sl@0:   if (!bus_connection_add_match_rule (rule->matches_go_to, rule))
sl@0:     {
sl@0:       _dbus_list_remove_last (&matchmaker->all_rules, rule);
sl@0:       return FALSE;
sl@0:     }
sl@0:   
sl@0:   bus_match_rule_ref (rule);
sl@0: 
sl@0: #ifdef DBUS_ENABLE_VERBOSE_MODE
sl@0:   {
sl@0:     char *s = match_rule_to_string (rule);
sl@0: 
sl@0:     _dbus_verbose ("Added match rule %s to connection %p\n",
sl@0:                    s, rule->matches_go_to);
sl@0:     dbus_free (s);
sl@0:   }
sl@0: #endif
sl@0:   
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: static dbus_bool_t
sl@0: match_rule_equal (BusMatchRule *a,
sl@0:                   BusMatchRule *b)
sl@0: {
sl@0:   if (a->flags != b->flags)
sl@0:     return FALSE;
sl@0: 
sl@0:   if (a->matches_go_to != b->matches_go_to)
sl@0:     return FALSE;
sl@0: 
sl@0:   if ((a->flags & BUS_MATCH_MESSAGE_TYPE) &&
sl@0:       a->message_type != b->message_type)
sl@0:     return FALSE;
sl@0: 
sl@0:   if ((a->flags & BUS_MATCH_MEMBER) &&
sl@0:       strcmp (a->member, b->member) != 0)
sl@0:     return FALSE;
sl@0: 
sl@0:   if ((a->flags & BUS_MATCH_PATH) &&
sl@0:       strcmp (a->path, b->path) != 0)
sl@0:     return FALSE;
sl@0:   
sl@0:   if ((a->flags & BUS_MATCH_INTERFACE) &&
sl@0:       strcmp (a->interface, b->interface) != 0)
sl@0:     return FALSE;
sl@0: 
sl@0:   if ((a->flags & BUS_MATCH_SENDER) &&
sl@0:       strcmp (a->sender, b->sender) != 0)
sl@0:     return FALSE;
sl@0: 
sl@0:   if ((a->flags & BUS_MATCH_DESTINATION) &&
sl@0:       strcmp (a->destination, b->destination) != 0)
sl@0:     return FALSE;
sl@0: 
sl@0:   if (a->flags & BUS_MATCH_ARGS)
sl@0:     {
sl@0:       int i;
sl@0:       
sl@0:       if (a->args_len != b->args_len)
sl@0:         return FALSE;
sl@0:       
sl@0:       i = 0;
sl@0:       while (i < a->args_len)
sl@0:         {
sl@0:           if ((a->args[i] != NULL) != (b->args[i] != NULL))
sl@0:             return FALSE;
sl@0: 
sl@0:           if (a->args[i] != NULL)
sl@0:             {
sl@0:               _dbus_assert (b->args[i] != NULL);
sl@0:               if (strcmp (a->args[i], b->args[i]) != 0)
sl@0:                 return FALSE;
sl@0:             }
sl@0:           
sl@0:           ++i;
sl@0:         }
sl@0:     }
sl@0:   
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: static void
sl@0: bus_matchmaker_remove_rule_link (BusMatchmaker   *matchmaker,
sl@0:                                  DBusList        *link)
sl@0: {
sl@0:   BusMatchRule *rule = link->data;
sl@0:   
sl@0:   bus_connection_remove_match_rule (rule->matches_go_to, rule);
sl@0:   _dbus_list_remove_link (&matchmaker->all_rules, link);
sl@0: 
sl@0: #ifdef DBUS_ENABLE_VERBOSE_MODE
sl@0:   {
sl@0:     char *s = match_rule_to_string (rule);
sl@0: 
sl@0:     _dbus_verbose ("Removed match rule %s for connection %p\n",
sl@0:                    s, rule->matches_go_to);
sl@0:     dbus_free (s);
sl@0:   }
sl@0: #endif
sl@0:   
sl@0:   bus_match_rule_unref (rule);  
sl@0: }
sl@0: 
sl@0: void
sl@0: bus_matchmaker_remove_rule (BusMatchmaker   *matchmaker,
sl@0:                             BusMatchRule    *rule)
sl@0: {
sl@0:   bus_connection_remove_match_rule (rule->matches_go_to, rule);
sl@0:   _dbus_list_remove (&matchmaker->all_rules, rule);
sl@0: 
sl@0: #ifdef DBUS_ENABLE_VERBOSE_MODE
sl@0:   {
sl@0:     char *s = match_rule_to_string (rule);
sl@0: 
sl@0:     _dbus_verbose ("Removed match rule %s for connection %p\n",
sl@0:                    s, rule->matches_go_to);
sl@0:     dbus_free (s);
sl@0:   }
sl@0: #endif
sl@0:   
sl@0:   bus_match_rule_unref (rule);
sl@0: }
sl@0: 
sl@0: /* Remove a single rule which is equal to the given rule by value */
sl@0: dbus_bool_t
sl@0: bus_matchmaker_remove_rule_by_value (BusMatchmaker   *matchmaker,
sl@0:                                      BusMatchRule    *value,
sl@0:                                      DBusError       *error)
sl@0: {
sl@0:   /* FIXME this is an unoptimized linear scan */
sl@0: 
sl@0:   DBusList *link;
sl@0: 
sl@0:   /* we traverse backward because bus_connection_remove_match_rule()
sl@0:    * removes the most-recently-added rule
sl@0:    */
sl@0:   link = _dbus_list_get_last_link (&matchmaker->all_rules);
sl@0:   while (link != NULL)
sl@0:     {
sl@0:       BusMatchRule *rule;
sl@0:       DBusList *prev;
sl@0: 
sl@0:       rule = link->data;
sl@0:       prev = _dbus_list_get_prev_link (&matchmaker->all_rules, link);
sl@0: 
sl@0:       if (match_rule_equal (rule, value))
sl@0:         {
sl@0:           bus_matchmaker_remove_rule_link (matchmaker, link);
sl@0:           break;
sl@0:         }
sl@0: 
sl@0:       link = prev;
sl@0:     }
sl@0: 
sl@0:   if (link == NULL)
sl@0:     {
sl@0:       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_NOT_FOUND,
sl@0:                       "The given match rule wasn't found and can't be removed");
sl@0:       return FALSE;
sl@0:     }
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: void
sl@0: bus_matchmaker_disconnected (BusMatchmaker   *matchmaker,
sl@0:                              DBusConnection  *disconnected)
sl@0: {
sl@0:   DBusList *link;
sl@0: 
sl@0:   /* FIXME
sl@0:    *
sl@0:    * This scans all match rules on the bus. We could avoid that
sl@0:    * for the rules belonging to the connection, since we keep
sl@0:    * a list of those; but for the rules that just refer to
sl@0:    * the connection we'd need to do something more elaborate.
sl@0:    * 
sl@0:    */
sl@0:   
sl@0:   _dbus_assert (bus_connection_is_active (disconnected));
sl@0: 
sl@0:   link = _dbus_list_get_first_link (&matchmaker->all_rules);
sl@0:   while (link != NULL)
sl@0:     {
sl@0:       BusMatchRule *rule;
sl@0:       DBusList *next;
sl@0: 
sl@0:       rule = link->data;
sl@0:       next = _dbus_list_get_next_link (&matchmaker->all_rules, link);
sl@0: 
sl@0:       if (rule->matches_go_to == disconnected)
sl@0:         {
sl@0:           bus_matchmaker_remove_rule_link (matchmaker, link);
sl@0:         }
sl@0:       else if (((rule->flags & BUS_MATCH_SENDER) && *rule->sender == ':') ||
sl@0:                ((rule->flags & BUS_MATCH_DESTINATION) && *rule->destination == ':'))
sl@0:         {
sl@0:           /* The rule matches to/from a base service, see if it's the
sl@0:            * one being disconnected, since we know this service name
sl@0:            * will never be recycled.
sl@0:            */
sl@0:           const char *name;
sl@0: 
sl@0:           name = bus_connection_get_name (disconnected);
sl@0:           _dbus_assert (name != NULL); /* because we're an active connection */
sl@0: 
sl@0:           if (((rule->flags & BUS_MATCH_SENDER) &&
sl@0:                strcmp (rule->sender, name) == 0) ||
sl@0:               ((rule->flags & BUS_MATCH_DESTINATION) &&
sl@0:                strcmp (rule->destination, name) == 0))
sl@0:             {
sl@0:               bus_matchmaker_remove_rule_link (matchmaker, link);
sl@0:             }
sl@0:         }
sl@0: 
sl@0:       link = next;
sl@0:     }
sl@0: }
sl@0: 
sl@0: static dbus_bool_t
sl@0: connection_is_primary_owner (DBusConnection *connection,
sl@0:                              const char     *service_name)
sl@0: {
sl@0:   BusService *service;
sl@0:   DBusString str;
sl@0:   BusRegistry *registry;
sl@0: 
sl@0:   _dbus_assert (connection != NULL);
sl@0:   
sl@0:   registry = bus_connection_get_registry (connection);
sl@0: 
sl@0:   _dbus_string_init_const (&str, service_name);
sl@0:   service = bus_registry_lookup (registry, &str);
sl@0: 
sl@0:   if (service == NULL)
sl@0:     return FALSE; /* Service doesn't exist so connection can't own it. */
sl@0: 
sl@0:   return bus_service_get_primary_owners_connection (service) == connection;
sl@0: }
sl@0: 
sl@0: static dbus_bool_t
sl@0: match_rule_matches (BusMatchRule    *rule,
sl@0:                     DBusConnection  *sender,
sl@0:                     DBusConnection  *addressed_recipient,
sl@0:                     DBusMessage     *message)
sl@0: {
sl@0:   /* All features of the match rule are AND'd together,
sl@0:    * so FALSE if any of them don't match.
sl@0:    */
sl@0: 
sl@0:   /* sender/addressed_recipient of #NULL may mean bus driver,
sl@0:    * or for addressed_recipient may mean a message with no
sl@0:    * specific recipient (i.e. a signal)
sl@0:    */
sl@0:   
sl@0:   if (rule->flags & BUS_MATCH_MESSAGE_TYPE)
sl@0:     {
sl@0:       _dbus_assert (rule->message_type != DBUS_MESSAGE_TYPE_INVALID);
sl@0: 
sl@0:       if (rule->message_type != dbus_message_get_type (message))
sl@0:         return FALSE;
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_INTERFACE)
sl@0:     {
sl@0:       const char *iface;
sl@0: 
sl@0:       _dbus_assert (rule->interface != NULL);
sl@0: 
sl@0:       iface = dbus_message_get_interface (message);
sl@0:       if (iface == NULL)
sl@0:         return FALSE;
sl@0: 
sl@0:       if (strcmp (iface, rule->interface) != 0)
sl@0:         return FALSE;
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_MEMBER)
sl@0:     {
sl@0:       const char *member;
sl@0: 
sl@0:       _dbus_assert (rule->member != NULL);
sl@0: 
sl@0:       member = dbus_message_get_member (message);
sl@0:       if (member == NULL)
sl@0:         return FALSE;
sl@0: 
sl@0:       if (strcmp (member, rule->member) != 0)
sl@0:         return FALSE;
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_SENDER)
sl@0:     {
sl@0:       _dbus_assert (rule->sender != NULL);
sl@0: 
sl@0:       if (sender == NULL)
sl@0:         {
sl@0:           if (strcmp (rule->sender,
sl@0:                       DBUS_SERVICE_DBUS) != 0)
sl@0:             return FALSE;
sl@0:         }
sl@0:       else
sl@0:         {
sl@0:           if (!connection_is_primary_owner (sender, rule->sender))
sl@0:             return FALSE;
sl@0:         }
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_DESTINATION)
sl@0:     {
sl@0:       const char *destination;
sl@0: 
sl@0:       _dbus_assert (rule->destination != NULL);
sl@0: 
sl@0:       destination = dbus_message_get_destination (message);
sl@0:       if (destination == NULL)
sl@0:         return FALSE;
sl@0: 
sl@0:       if (addressed_recipient == NULL)
sl@0:         {          
sl@0:           if (strcmp (rule->destination,
sl@0:                       DBUS_SERVICE_DBUS) != 0)
sl@0:             return FALSE;
sl@0:         }
sl@0:       else
sl@0:         {
sl@0:           if (!connection_is_primary_owner (addressed_recipient, rule->destination))
sl@0:             return FALSE;
sl@0:         }
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_PATH)
sl@0:     {
sl@0:       const char *path;
sl@0: 
sl@0:       _dbus_assert (rule->path != NULL);
sl@0: 
sl@0:       path = dbus_message_get_path (message);
sl@0:       if (path == NULL)
sl@0:         return FALSE;
sl@0: 
sl@0:       if (strcmp (path, rule->path) != 0)
sl@0:         return FALSE;
sl@0:     }
sl@0: 
sl@0:   if (rule->flags & BUS_MATCH_ARGS)
sl@0:     {
sl@0:       int i;
sl@0:       DBusMessageIter iter;
sl@0:       
sl@0:       _dbus_assert (rule->args != NULL);
sl@0: 
sl@0:       dbus_message_iter_init (message, &iter);
sl@0:       
sl@0:       i = 0;
sl@0:       while (i < rule->args_len)
sl@0:         {
sl@0:           int current_type;
sl@0:           const char *expected_arg;
sl@0: 
sl@0:           expected_arg = rule->args[i];
sl@0:           
sl@0:           current_type = dbus_message_iter_get_arg_type (&iter);
sl@0: 
sl@0:           if (expected_arg != NULL)
sl@0:             {
sl@0:               const char *actual_arg;
sl@0:               
sl@0:               if (current_type != DBUS_TYPE_STRING)
sl@0:                 return FALSE;
sl@0: 
sl@0:               actual_arg = NULL;
sl@0:               dbus_message_iter_get_basic (&iter, &actual_arg);
sl@0:               _dbus_assert (actual_arg != NULL);
sl@0: 
sl@0:               if (strcmp (expected_arg, actual_arg) != 0)
sl@0:                 return FALSE;
sl@0:             }
sl@0:           
sl@0:           if (current_type != DBUS_TYPE_INVALID)
sl@0:             dbus_message_iter_next (&iter);
sl@0: 
sl@0:           ++i;
sl@0:         }
sl@0:     }
sl@0:   
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_matchmaker_get_recipients (BusMatchmaker   *matchmaker,
sl@0:                                BusConnections  *connections,
sl@0:                                DBusConnection  *sender,
sl@0:                                DBusConnection  *addressed_recipient,
sl@0:                                DBusMessage     *message,
sl@0:                                DBusList       **recipients_p)
sl@0: {
sl@0:   /* FIXME for now this is a wholly unoptimized linear search */
sl@0:   /* Guessing the important optimization is to skip the signal-related
sl@0:    * match lists when processing method call and exception messages.
sl@0:    * So separate match rule lists for signals?
sl@0:    */
sl@0:   
sl@0:   DBusList *link;
sl@0: 
sl@0:   _dbus_assert (*recipients_p == NULL);
sl@0: 
sl@0:   /* This avoids sending same message to the same connection twice.
sl@0:    * Purpose of the stamp instead of a bool is to avoid iterating over
sl@0:    * all connections resetting the bool each time.
sl@0:    */
sl@0:   bus_connections_increment_stamp (connections);
sl@0: 
sl@0:   /* addressed_recipient is already receiving the message, don't add to list.
sl@0:    * NULL addressed_recipient means either bus driver, or this is a signal
sl@0:    * and thus lacks a specific addressed_recipient.
sl@0:    */
sl@0:   if (addressed_recipient != NULL)
sl@0:     bus_connection_mark_stamp (addressed_recipient);
sl@0: 
sl@0:   link = _dbus_list_get_first_link (&matchmaker->all_rules);
sl@0:   while (link != NULL)
sl@0:     {
sl@0:       BusMatchRule *rule;
sl@0: 
sl@0:       rule = link->data;
sl@0: 
sl@0: #ifdef DBUS_ENABLE_VERBOSE_MODE
sl@0:       {
sl@0:         char *s = match_rule_to_string (rule);
sl@0:         
sl@0:         _dbus_verbose ("Checking whether message matches rule %s for connection %p\n",
sl@0:                        s, rule->matches_go_to);
sl@0:         dbus_free (s);
sl@0:       }
sl@0: #endif
sl@0:       
sl@0:       if (match_rule_matches (rule,
sl@0:                               sender, addressed_recipient, message))
sl@0:         {
sl@0:           _dbus_verbose ("Rule matched\n");
sl@0:           
sl@0:           /* Append to the list if we haven't already */
sl@0:           if (bus_connection_mark_stamp (rule->matches_go_to))
sl@0:             {
sl@0:               if (!_dbus_list_append (recipients_p, rule->matches_go_to))
sl@0:                 goto nomem;
sl@0:             }
sl@0: #ifdef DBUS_ENABLE_VERBOSE_MODE
sl@0:           else
sl@0:             {
sl@0:               _dbus_verbose ("Connection already receiving this message, so not adding again\n");
sl@0:             }
sl@0: #endif /* DBUS_ENABLE_VERBOSE_MODE */
sl@0:         }
sl@0: 
sl@0:       link = _dbus_list_get_next_link (&matchmaker->all_rules, link);
sl@0:     }
sl@0: 
sl@0:   return TRUE;
sl@0: 
sl@0:  nomem:
sl@0:   _dbus_list_clear (recipients_p);
sl@0:   return FALSE;
sl@0: }
sl@0: 
sl@0: #ifdef DBUS_BUILD_TESTS
sl@0: #include "test.h"
sl@0: #include <stdlib.h>
sl@0: 
sl@0: static BusMatchRule*
sl@0: check_parse (dbus_bool_t should_succeed,
sl@0:              const char *text)
sl@0: {
sl@0:   BusMatchRule *rule;
sl@0:   DBusString str;
sl@0:   DBusError error;
sl@0: 
sl@0:   dbus_error_init (&error);
sl@0: 
sl@0:   _dbus_string_init_const (&str, text);
sl@0:   
sl@0:   rule = bus_match_rule_parse (NULL, &str, &error);
sl@0:   if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
sl@0:     {
sl@0:       dbus_error_free (&error);
sl@0:       return NULL;
sl@0:     }
sl@0: 
sl@0:   if (should_succeed && rule == NULL)
sl@0:     {
sl@0:       _dbus_warn ("Failed to parse: %s: %s: \"%s\"\n",
sl@0:                   error.name, error.message,
sl@0:                   _dbus_string_get_const_data (&str));
sl@0:       exit (1);
sl@0:     }
sl@0: 
sl@0:   if (!should_succeed && rule != NULL)
sl@0:     {
sl@0:       _dbus_warn ("Failed to fail to parse: \"%s\"\n",
sl@0:                   _dbus_string_get_const_data (&str));
sl@0:       exit (1);
sl@0:     }
sl@0: 
sl@0:   dbus_error_free (&error);
sl@0: 
sl@0:   return rule;
sl@0: }
sl@0: 
sl@0: static void
sl@0: assert_large_rule (BusMatchRule *rule)
sl@0: {
sl@0:   _dbus_assert (rule->flags & BUS_MATCH_MESSAGE_TYPE);
sl@0:   _dbus_assert (rule->flags & BUS_MATCH_SENDER);
sl@0:   _dbus_assert (rule->flags & BUS_MATCH_INTERFACE);
sl@0:   _dbus_assert (rule->flags & BUS_MATCH_MEMBER);
sl@0:   _dbus_assert (rule->flags & BUS_MATCH_DESTINATION);
sl@0:   _dbus_assert (rule->flags & BUS_MATCH_PATH);
sl@0: 
sl@0:   _dbus_assert (rule->message_type == DBUS_MESSAGE_TYPE_SIGNAL);
sl@0:   _dbus_assert (rule->interface != NULL);
sl@0:   _dbus_assert (rule->member != NULL);
sl@0:   _dbus_assert (rule->sender != NULL);
sl@0:   _dbus_assert (rule->destination != NULL);
sl@0:   _dbus_assert (rule->path != NULL);
sl@0: 
sl@0:   _dbus_assert (strcmp (rule->interface, "org.freedesktop.DBusInterface") == 0);
sl@0:   _dbus_assert (strcmp (rule->sender, "org.freedesktop.DBusSender") == 0);
sl@0:   _dbus_assert (strcmp (rule->member, "Foo") == 0);
sl@0:   _dbus_assert (strcmp (rule->path, "/bar/foo") == 0);
sl@0:   _dbus_assert (strcmp (rule->destination, ":452345.34") == 0);
sl@0: }
sl@0: 
sl@0: static dbus_bool_t
sl@0: test_parsing (void *data)
sl@0: {
sl@0:   BusMatchRule *rule;
sl@0: 
sl@0:   rule = check_parse (TRUE, "type='signal',sender='org.freedesktop.DBusSender',interface='org.freedesktop.DBusInterface',member='Foo',path='/bar/foo',destination=':452345.34'");
sl@0:   if (rule != NULL)
sl@0:     {
sl@0:       assert_large_rule (rule);
sl@0:       bus_match_rule_unref (rule);
sl@0:     }
sl@0: 
sl@0:   /* With extra whitespace and useless quotes */
sl@0:   rule = check_parse (TRUE, "    type='signal',  \tsender='org.freedes''ktop.DBusSender',   interface='org.freedesktop.DBusInterface''''', \tmember='Foo',path='/bar/foo',destination=':452345.34'''''");
sl@0:   if (rule != NULL)
sl@0:     {
sl@0:       assert_large_rule (rule);
sl@0:       bus_match_rule_unref (rule);
sl@0:     }
sl@0: 
sl@0: 
sl@0:   /* A simple signal connection */
sl@0:   rule = check_parse (TRUE, "type='signal',path='/foo',interface='org.Bar'");
sl@0:   if (rule != NULL)
sl@0:     {
sl@0:       _dbus_assert (rule->flags & BUS_MATCH_MESSAGE_TYPE);
sl@0:       _dbus_assert (rule->flags & BUS_MATCH_INTERFACE);
sl@0:       _dbus_assert (rule->flags & BUS_MATCH_PATH);
sl@0: 
sl@0:       _dbus_assert (rule->message_type == DBUS_MESSAGE_TYPE_SIGNAL);
sl@0:       _dbus_assert (rule->interface != NULL);
sl@0:       _dbus_assert (rule->path != NULL);
sl@0: 
sl@0:       _dbus_assert (strcmp (rule->interface, "org.Bar") == 0);
sl@0:       _dbus_assert (strcmp (rule->path, "/foo") == 0);
sl@0:   
sl@0:       bus_match_rule_unref (rule);
sl@0:     }
sl@0: 
sl@0:   /* argN */
sl@0:   rule = check_parse (TRUE, "arg0='foo'");
sl@0:   if (rule != NULL)
sl@0:     {
sl@0:       _dbus_assert (rule->flags == BUS_MATCH_ARGS);
sl@0:       _dbus_assert (rule->args != NULL);
sl@0:       _dbus_assert (rule->args_len == 1);
sl@0:       _dbus_assert (rule->args[0] != NULL);
sl@0:       _dbus_assert (rule->args[1] == NULL);
sl@0:       _dbus_assert (strcmp (rule->args[0], "foo") == 0);
sl@0: 
sl@0:       bus_match_rule_unref (rule);
sl@0:     }
sl@0:   
sl@0:   rule = check_parse (TRUE, "arg1='foo'");
sl@0:   if (rule != NULL)
sl@0:     {
sl@0:       _dbus_assert (rule->flags == BUS_MATCH_ARGS);
sl@0:       _dbus_assert (rule->args != NULL);
sl@0:       _dbus_assert (rule->args_len == 2);
sl@0:       _dbus_assert (rule->args[0] == NULL);
sl@0:       _dbus_assert (rule->args[1] != NULL);
sl@0:       _dbus_assert (rule->args[2] == NULL);
sl@0:       _dbus_assert (strcmp (rule->args[1], "foo") == 0);
sl@0: 
sl@0:       bus_match_rule_unref (rule);
sl@0:     }
sl@0: 
sl@0:   rule = check_parse (TRUE, "arg2='foo'");
sl@0:   if (rule != NULL)
sl@0:     {
sl@0:       _dbus_assert (rule->flags == BUS_MATCH_ARGS);
sl@0:       _dbus_assert (rule->args != NULL);
sl@0:       _dbus_assert (rule->args_len == 3);
sl@0:       _dbus_assert (rule->args[0] == NULL);
sl@0:       _dbus_assert (rule->args[1] == NULL);
sl@0:       _dbus_assert (rule->args[2] != NULL);
sl@0:       _dbus_assert (rule->args[3] == NULL);
sl@0:       _dbus_assert (strcmp (rule->args[2], "foo") == 0);
sl@0: 
sl@0:       bus_match_rule_unref (rule);
sl@0:     }
sl@0:   
sl@0:   rule = check_parse (TRUE, "arg40='foo'");
sl@0:   if (rule != NULL)
sl@0:     {
sl@0:       _dbus_assert (rule->flags == BUS_MATCH_ARGS);
sl@0:       _dbus_assert (rule->args != NULL);
sl@0:       _dbus_assert (rule->args_len == 41);
sl@0:       _dbus_assert (rule->args[0] == NULL);
sl@0:       _dbus_assert (rule->args[1] == NULL);
sl@0:       _dbus_assert (rule->args[40] != NULL);
sl@0:       _dbus_assert (rule->args[41] == NULL);
sl@0:       _dbus_assert (strcmp (rule->args[40], "foo") == 0);
sl@0: 
sl@0:       bus_match_rule_unref (rule);
sl@0:     }
sl@0:   
sl@0:   rule = check_parse (TRUE, "arg63='foo'");
sl@0:   if (rule != NULL)
sl@0:     {
sl@0:       _dbus_assert (rule->flags == BUS_MATCH_ARGS);
sl@0:       _dbus_assert (rule->args != NULL);
sl@0:       _dbus_assert (rule->args_len == 64);
sl@0:       _dbus_assert (rule->args[0] == NULL);
sl@0:       _dbus_assert (rule->args[1] == NULL);
sl@0:       _dbus_assert (rule->args[63] != NULL);
sl@0:       _dbus_assert (rule->args[64] == NULL);
sl@0:       _dbus_assert (strcmp (rule->args[63], "foo") == 0);
sl@0: 
sl@0:       bus_match_rule_unref (rule);
sl@0:     }
sl@0:   
sl@0:   /* Too-large argN */
sl@0:   rule = check_parse (FALSE, "arg300='foo'");
sl@0:   _dbus_assert (rule == NULL);
sl@0:   rule = check_parse (FALSE, "arg64='foo'");
sl@0:   _dbus_assert (rule == NULL);
sl@0: 
sl@0:   /* No N in argN */
sl@0:   rule = check_parse (FALSE, "arg='foo'");
sl@0:   _dbus_assert (rule == NULL);
sl@0:   rule = check_parse (FALSE, "argv='foo'");
sl@0:   _dbus_assert (rule == NULL);
sl@0:   rule = check_parse (FALSE, "arg3junk='foo'");
sl@0:   _dbus_assert (rule == NULL);
sl@0:   rule = check_parse (FALSE, "argument='foo'");
sl@0:   _dbus_assert (rule == NULL);
sl@0:   
sl@0:   /* Reject duplicates */
sl@0:   rule = check_parse (FALSE, "type='signal',type='method_call'");
sl@0:   _dbus_assert (rule == NULL);
sl@0: 
sl@0:   /* Duplicates with the argN code */
sl@0:   rule = check_parse (FALSE, "arg0='foo',arg0='bar'");
sl@0:   _dbus_assert (rule == NULL);
sl@0:   rule = check_parse (FALSE, "arg3='foo',arg3='bar'");
sl@0:   _dbus_assert (rule == NULL);
sl@0:   rule = check_parse (FALSE, "arg30='foo',arg30='bar'");
sl@0:   _dbus_assert (rule == NULL);
sl@0:   
sl@0:   /* Reject broken keys */
sl@0:   rule = check_parse (FALSE, "blah='signal'");
sl@0:   _dbus_assert (rule == NULL);
sl@0: 
sl@0:   /* Reject broken values */
sl@0:   rule = check_parse (FALSE, "type='chouin'");
sl@0:   _dbus_assert (rule == NULL);
sl@0:   rule = check_parse (FALSE, "interface='abc@def++'");
sl@0:   _dbus_assert (rule == NULL);
sl@0:   rule = check_parse (FALSE, "service='youpi'");
sl@0:   _dbus_assert (rule == NULL);
sl@0: 
sl@0:   /* Allow empty rule */
sl@0:   rule = check_parse (TRUE, "");
sl@0:   if (rule != NULL)
sl@0:     {
sl@0:       _dbus_assert (rule->flags == 0);
sl@0:       
sl@0:       bus_match_rule_unref (rule);
sl@0:     }
sl@0: 
sl@0:   /* All-whitespace rule is the same as empty */
sl@0:   rule = check_parse (TRUE, "    \t");
sl@0:   if (rule != NULL)
sl@0:     {
sl@0:       _dbus_assert (rule->flags == 0);
sl@0:       
sl@0:       bus_match_rule_unref (rule);
sl@0:     }
sl@0: 
sl@0:   /* But with non-whitespace chars and no =value, it's not OK */
sl@0:   rule = check_parse (FALSE, "type");
sl@0:   _dbus_assert (rule == NULL);
sl@0:   
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: static struct {
sl@0:   const char *first;
sl@0:   const char *second;
sl@0: } equality_tests[] = {
sl@0:   { "type='signal'", "type='signal'" },
sl@0:   { "type='signal',interface='foo.bar'", "interface='foo.bar',type='signal'" },
sl@0:   { "type='signal',member='bar'", "member='bar',type='signal'" },
sl@0:   { "type='method_call',sender=':1.0'", "sender=':1.0',type='method_call'" },
sl@0:   { "type='method_call',destination=':1.0'", "destination=':1.0',type='method_call'" },
sl@0:   { "type='method_call',path='/foo/bar'", "path='/foo/bar',type='method_call'" },
sl@0:   { "type='method_call',arg0='blah'", "arg0='blah',type='method_call'" },
sl@0:   { "type='method_call',arg0='boo'", "arg0='boo',type='method_call'" },
sl@0:   { "type='method_call',arg0='blah',arg1='baz'", "arg0='blah',arg1='baz',type='method_call'" },
sl@0:   { "type='method_call',arg3='foosh'", "arg3='foosh',type='method_call'" },
sl@0:   { "arg3='fool'", "arg3='fool'" },
sl@0:   { "member='food'", "member='food'" }
sl@0: };
sl@0: 
sl@0: static void
sl@0: test_equality (void)
sl@0: {
sl@0:   int i;
sl@0:   
sl@0:   i = 0;
sl@0:   while (i < _DBUS_N_ELEMENTS (equality_tests))
sl@0:     {
sl@0:       BusMatchRule *first;
sl@0:       BusMatchRule *second;
sl@0:       int j;
sl@0:       
sl@0:       first = check_parse (TRUE, equality_tests[i].first);
sl@0:       _dbus_assert (first != NULL);
sl@0:       second = check_parse (TRUE, equality_tests[i].second);
sl@0:       _dbus_assert (second != NULL);
sl@0: 
sl@0:       if (!match_rule_equal (first, second))
sl@0:         {
sl@0:           _dbus_warn ("rule %s and %s should have been equal\n",
sl@0:                       equality_tests[i].first,
sl@0:                       equality_tests[i].second);
sl@0:           exit (1);
sl@0:         }
sl@0: 
sl@0:       bus_match_rule_unref (second);
sl@0: 
sl@0:       /* Check that the rule is not equal to any of the
sl@0:        * others besides its pair match
sl@0:        */
sl@0:       j = 0;
sl@0:       while (j < _DBUS_N_ELEMENTS (equality_tests))
sl@0:         {
sl@0:           if (i != j)
sl@0:             {
sl@0:               second = check_parse (TRUE, equality_tests[j].second);
sl@0: 
sl@0:               if (match_rule_equal (first, second))
sl@0:                 {
sl@0:                   _dbus_warn ("rule %s and %s should not have been equal\n",
sl@0:                               equality_tests[i].first,
sl@0:                               equality_tests[j].second);
sl@0:                   exit (1);
sl@0:                 }
sl@0:               
sl@0:               bus_match_rule_unref (second);
sl@0:             }
sl@0:           
sl@0:           ++j;
sl@0:         }
sl@0: 
sl@0:       bus_match_rule_unref (first);
sl@0: 
sl@0:       ++i;
sl@0:     }
sl@0: }
sl@0: 
sl@0: static const char*
sl@0: should_match_message_1[] = {
sl@0:   "type='signal'",
sl@0:   "member='Frobated'",
sl@0:   "arg0='foobar'",
sl@0:   "type='signal',member='Frobated'",
sl@0:   "type='signal',member='Frobated',arg0='foobar'",
sl@0:   "member='Frobated',arg0='foobar'",
sl@0:   "type='signal',arg0='foobar'",
sl@0:   NULL
sl@0: };
sl@0: 
sl@0: static const char*
sl@0: should_not_match_message_1[] = {
sl@0:   "type='method_call'",
sl@0:   "type='error'",
sl@0:   "type='method_return'",
sl@0:   "type='signal',member='Oopsed'",
sl@0:   "arg0='blah'",
sl@0:   "arg1='foobar'",
sl@0:   "arg2='foobar'",
sl@0:   "arg3='foobar'",
sl@0:   "arg0='3'",
sl@0:   "arg1='3'",
sl@0:   "arg0='foobar',arg1='abcdef'",
sl@0:   "arg0='foobar',arg1='abcdef',arg2='abcdefghi',arg3='abcdefghi',arg4='abcdefghi'",
sl@0:   "arg0='foobar',arg1='abcdef',arg4='abcdefghi',arg3='abcdefghi',arg2='abcdefghi'",
sl@0:   NULL
sl@0: };
sl@0: 
sl@0: static void
sl@0: check_matches (dbus_bool_t  expected_to_match,
sl@0:                int          number,
sl@0:                DBusMessage *message,
sl@0:                const char  *rule_text)
sl@0: {
sl@0:   BusMatchRule *rule;
sl@0:   dbus_bool_t matched;
sl@0: 
sl@0:   rule = check_parse (TRUE, rule_text);
sl@0:   _dbus_assert (rule != NULL);
sl@0: 
sl@0:   /* We can't test sender/destination rules since we pass NULL here */
sl@0:   matched = match_rule_matches (rule, NULL, NULL, message);
sl@0: 
sl@0:   if (matched != expected_to_match)
sl@0:     {
sl@0:       _dbus_warn ("Expected rule %s to %s message %d, failed\n",
sl@0:                   rule_text, expected_to_match ?
sl@0:                   "match" : "not match", number);
sl@0:       exit (1);
sl@0:     }
sl@0: 
sl@0:   bus_match_rule_unref (rule);
sl@0: }
sl@0: 
sl@0: static void
sl@0: check_matching (DBusMessage *message,
sl@0:                 int          number,
sl@0:                 const char **should_match,
sl@0:                 const char **should_not_match)
sl@0: {
sl@0:   int i;
sl@0: 
sl@0:   i = 0;
sl@0:   while (should_match[i] != NULL)
sl@0:     {
sl@0:       check_matches (TRUE, number, message, should_match[i]);
sl@0:       ++i;
sl@0:     }
sl@0: 
sl@0:   i = 0;
sl@0:   while (should_not_match[i] != NULL)
sl@0:     {
sl@0:       check_matches (FALSE, number, message, should_not_match[i]);
sl@0:       ++i;
sl@0:     }
sl@0: }
sl@0: 
sl@0: static void
sl@0: test_matching (void)
sl@0: {
sl@0:   DBusMessage *message1;
sl@0:   const char *v_STRING;
sl@0:   dbus_int32_t v_INT32;
sl@0: 
sl@0:   message1 = dbus_message_new (DBUS_MESSAGE_TYPE_SIGNAL);
sl@0:   _dbus_assert (message1 != NULL);
sl@0:   if (!dbus_message_set_member (message1, "Frobated"))
sl@0:     _dbus_assert_not_reached ("oom");
sl@0: 
sl@0:   v_STRING = "foobar";
sl@0:   v_INT32 = 3;
sl@0:   if (!dbus_message_append_args (message1,
sl@0:                                  DBUS_TYPE_STRING, &v_STRING,
sl@0:                                  DBUS_TYPE_INT32, &v_INT32,
sl@0:                                  NULL))
sl@0:     _dbus_assert_not_reached ("oom");
sl@0:   
sl@0:   check_matching (message1, 1,
sl@0:                   should_match_message_1,
sl@0:                   should_not_match_message_1);
sl@0:   
sl@0:   dbus_message_unref (message1);
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_signals_test (const DBusString *test_data_dir)
sl@0: {
sl@0:   BusMatchmaker *matchmaker;
sl@0: 
sl@0:   matchmaker = bus_matchmaker_new ();
sl@0:   bus_matchmaker_ref (matchmaker);
sl@0:   bus_matchmaker_unref (matchmaker);
sl@0:   bus_matchmaker_unref (matchmaker);
sl@0: 
sl@0:   if (!_dbus_test_oom_handling ("parsing match rules", test_parsing, NULL))
sl@0:     _dbus_assert_not_reached ("Parsing match rules test failed");
sl@0: 
sl@0:   test_equality ();
sl@0: 
sl@0:   test_matching ();
sl@0:   
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: #endif /* DBUS_BUILD_TESTS */
sl@0: