1 /* -*- mode: C; c-file-style: "gnu" -*- */

     2 /* signals.c  Bus signal connection implementation

     3  *

     4  * Copyright (C) 2003, 2005  Red Hat, Inc.

     5  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     6  * Licensed under the Academic Free License version 2.1

     7  *

     8  * This program is free software; you can redistribute it and/or modify

     9  * it under the terms of the GNU General Public License as published by

    10  * the Free Software Foundation; either version 2 of the License, or

    11  * (at your option) any later version.

    12  *

    13  * This program is distributed in the hope that it will be useful,

    14  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    16  * GNU General Public License for more details.

    17  *

    18  * You should have received a copy of the GNU General Public License

    19  * along with this program; if not, write to the Free Software

    20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    21  *

    22  */

    23 #include "signals.h"

    24 #include "services.h"

    25 #include "utils.h"

    26 #ifndef __SYMBIAN32__

    27 #include <dbus/dbus-marshal-validate.h>

    28 #else

    29 #include "dbus-marshal-validate.h"

    30 #include "config.h"

    31 #endif //__SYMBIAN32__

    32 

    33 struct BusMatchRule

    34 {

    35   int refcount;       /**< reference count */

    36 

    37   DBusConnection *matches_go_to; /**< Owner of the rule */

    38 

    39   unsigned int flags; /**< BusMatchFlags */

    40 

    41   int   message_type;

    42   char *interface;

    43   char *member;

    44   char *sender;

    45   char *destination;

    46   char *path;

    47 

    48   char **args;

    49   int args_len;

    50 };

    51 

    52 BusMatchRule*

    53 bus_match_rule_new (DBusConnection *matches_go_to)

    54 {

    55   BusMatchRule *rule;

    56 

    57   rule = dbus_new0 (BusMatchRule, 1);

    58   if (rule == NULL)

    59     return NULL;

    60 

    61   rule->refcount = 1;

    62   rule->matches_go_to = matches_go_to;

    63 

    64 #ifndef DBUS_BUILD_TESTS

    65   _dbus_assert (rule->matches_go_to != NULL);

    66 #endif

    67   

    68   return rule;

    69 }

    70 

    71 BusMatchRule *

    72 bus_match_rule_ref (BusMatchRule *rule)

    73 {

    74   _dbus_assert (rule->refcount > 0);

    75 

    76   rule->refcount += 1;

    77 

    78   return rule;

    79 }

    80 

    81 void

    82 bus_match_rule_unref (BusMatchRule *rule)

    83 {

    84   _dbus_assert (rule->refcount > 0);

    85 

    86   rule->refcount -= 1;

    87   if (rule->refcount == 0)

    88     {

    89       dbus_free (rule->interface);

    90       dbus_free (rule->member);

    91       dbus_free (rule->sender);

    92       dbus_free (rule->destination);

    93       dbus_free (rule->path);

    94 

    95       /* can't use dbus_free_string_array() since there

    96        * are embedded NULL

    97        */

    98       if (rule->args)

    99         {

   100           int i;

   101 

   102           i = 0;

   103           while (i < rule->args_len)

   104             {

   105               if (rule->args[i])

   106                 dbus_free (rule->args[i]);

   107               ++i;

   108             }

   109 

   110           dbus_free (rule->args);

   111         }

   112       

   113       dbus_free (rule);

   114     }

   115 }

   116 

   117 #ifdef DBUS_ENABLE_VERBOSE_MODE

   118 /* Note this function does not do escaping, so it's only

   119  * good for debug spew at the moment

   120  */

   121 static char*

   122 match_rule_to_string (BusMatchRule *rule)

   123 {

   124   DBusString str;

   125   char *ret;

   126   

   127   if (!_dbus_string_init (&str))

   128     {

   129       char *s;

   130       while ((s = _dbus_strdup ("nomem")) == NULL)

   131         ; /* only OK for debug spew... */

   132       return s;

   133     }

   134   

   135   if (rule->flags & BUS_MATCH_MESSAGE_TYPE)

   136     {

   137       /* FIXME make type readable */

   138       if (!_dbus_string_append_printf (&str, "type='%d'", rule->message_type))

   139         goto nomem;

   140     }

   141 

   142   if (rule->flags & BUS_MATCH_INTERFACE)

   143     {

   144       if (_dbus_string_get_length (&str) > 0)

   145         {

   146           if (!_dbus_string_append (&str, ","))

   147             goto nomem;

   148         }

   149       

   150       if (!_dbus_string_append_printf (&str, "interface='%s'", rule->interface))

   151         goto nomem;

   152     }

   153 

   154   if (rule->flags & BUS_MATCH_MEMBER)

   155     {

   156       if (_dbus_string_get_length (&str) > 0)

   157         {

   158           if (!_dbus_string_append (&str, ","))

   159             goto nomem;

   160         }

   161       

   162       if (!_dbus_string_append_printf (&str, "member='%s'", rule->member))

   163         goto nomem;

   164     }

   165 

   166   if (rule->flags & BUS_MATCH_PATH)

   167     {

   168       if (_dbus_string_get_length (&str) > 0)

   169         {

   170           if (!_dbus_string_append (&str, ","))

   171             goto nomem;

   172         }

   173       

   174       if (!_dbus_string_append_printf (&str, "path='%s'", rule->path))

   175         goto nomem;

   176     }

   177 

   178   if (rule->flags & BUS_MATCH_SENDER)

   179     {

   180       if (_dbus_string_get_length (&str) > 0)

   181         {

   182           if (!_dbus_string_append (&str, ","))

   183             goto nomem;

   184         }

   185       

   186       if (!_dbus_string_append_printf (&str, "sender='%s'", rule->sender))

   187         goto nomem;

   188     }

   189 

   190   if (rule->flags & BUS_MATCH_DESTINATION)

   191     {

   192       if (_dbus_string_get_length (&str) > 0)

   193         {

   194           if (!_dbus_string_append (&str, ","))

   195             goto nomem;

   196         }

   197       

   198       if (!_dbus_string_append_printf (&str, "destination='%s'", rule->destination))

   199         goto nomem;

   200     }

   201 

   202   if (rule->flags & BUS_MATCH_ARGS)

   203     {

   204       int i;

   205       

   206       _dbus_assert (rule->args != NULL);

   207 

   208       i = 0;

   209       while (i < rule->args_len)

   210         {

   211           if (rule->args[i] != NULL)

   212             {

   213               if (_dbus_string_get_length (&str) > 0)

   214                 {

   215                   if (!_dbus_string_append (&str, ","))

   216                     goto nomem;

   217                 }

   218               

   219               if (!_dbus_string_append_printf (&str,

   220                                                "arg%d='%s'",

   221                                                i,

   222                                                rule->args[i]))

   223                 goto nomem;

   224             }

   225           

   226           ++i;

   227         }

   228     }

   229   

   230   if (!_dbus_string_steal_data (&str, &ret))

   231     goto nomem;

   232 

   233   _dbus_string_free (&str);

   234   return ret;

   235   

   236  nomem:

   237   _dbus_string_free (&str);

   238   {

   239     char *s;

   240     while ((s = _dbus_strdup ("nomem")) == NULL)

   241       ;  /* only OK for debug spew... */

   242     return s;

   243   }

   244 }

   245 #endif /* DBUS_ENABLE_VERBOSE_MODE */

   246 

   247 dbus_bool_t

   248 bus_match_rule_set_message_type (BusMatchRule *rule,

   249                                  int           type)

   250 {

   251   rule->flags |= BUS_MATCH_MESSAGE_TYPE;

   252 

   253   rule->message_type = type;

   254 

   255   return TRUE;

   256 }

   257 

   258 dbus_bool_t

   259 bus_match_rule_set_interface (BusMatchRule *rule,

   260                               const char   *interface)

   261 {

   262   char *new;

   263 

   264   _dbus_assert (interface != NULL);

   265 

   266   new = _dbus_strdup (interface);

   267   if (new == NULL)

   268     return FALSE;

   269 

   270   rule->flags |= BUS_MATCH_INTERFACE;

   271   dbus_free (rule->interface);

   272   rule->interface = new;

   273 

   274   return TRUE;

   275 }

   276 

   277 dbus_bool_t

   278 bus_match_rule_set_member (BusMatchRule *rule,

   279                            const char   *member)

   280 {

   281   char *new;

   282 

   283   _dbus_assert (member != NULL);

   284 

   285   new = _dbus_strdup (member);

   286   if (new == NULL)

   287     return FALSE;

   288 

   289   rule->flags |= BUS_MATCH_MEMBER;

   290   dbus_free (rule->member);

   291   rule->member = new;

   292 

   293   return TRUE;

   294 }

   295 

   296 dbus_bool_t

   297 bus_match_rule_set_sender (BusMatchRule *rule,

   298                            const char   *sender)

   299 {

   300   char *new;

   301 

   302   _dbus_assert (sender != NULL);

   303 

   304   new = _dbus_strdup (sender);

   305   if (new == NULL)

   306     return FALSE;

   307 

   308   rule->flags |= BUS_MATCH_SENDER;

   309   dbus_free (rule->sender);

   310   rule->sender = new;

   311 

   312   return TRUE;

   313 }

   314 

   315 dbus_bool_t

   316 bus_match_rule_set_destination (BusMatchRule *rule,

   317                                 const char   *destination)

   318 {

   319   char *new;

   320 

   321   _dbus_assert (destination != NULL);

   322 

   323   new = _dbus_strdup (destination);

   324   if (new == NULL)

   325     return FALSE;

   326 

   327   rule->flags |= BUS_MATCH_DESTINATION;

   328   dbus_free (rule->destination);

   329   rule->destination = new;

   330 

   331   return TRUE;

   332 }

   333 

   334 dbus_bool_t

   335 bus_match_rule_set_path (BusMatchRule *rule,

   336                          const char   *path)

   337 {

   338   char *new;

   339 

   340   _dbus_assert (path != NULL);

   341 

   342   new = _dbus_strdup (path);

   343   if (new == NULL)

   344     return FALSE;

   345 

   346   rule->flags |= BUS_MATCH_PATH;

   347   dbus_free (rule->path);

   348   rule->path = new;

   349 

   350   return TRUE;

   351 }

   352 

   353 dbus_bool_t

   354 bus_match_rule_set_arg (BusMatchRule *rule,

   355                         int           arg,

   356                         const char   *value)

   357 {

   358   char *new;

   359 

   360   _dbus_assert (value != NULL);

   361 

   362   new = _dbus_strdup (value);

   363   if (new == NULL)

   364     return FALSE;

   365 

   366   /* args_len is the number of args not including null termination

   367    * in the char**

   368    */

   369   if (arg >= rule->args_len)

   370     {

   371       char **new_args;

   372       int new_args_len;

   373       int i;

   374 

   375       new_args_len = arg + 1;

   376 

   377       /* add another + 1 here for null termination */

   378       new_args = dbus_realloc (rule->args,

   379                                sizeof(rule->args[0]) * (new_args_len + 1));

   380       if (new_args == NULL)

   381         {

   382           dbus_free (new);

   383           return FALSE;

   384         }

   385 

   386       /* NULL the new slots */

   387       i = rule->args_len;

   388       while (i <= new_args_len) /* <= for null termination */

   389         {

   390           new_args[i] = NULL;

   391           ++i;

   392         }

   393       

   394       rule->args = new_args;

   395       rule->args_len = new_args_len;

   396     }

   397 

   398   rule->flags |= BUS_MATCH_ARGS;

   399 

   400   dbus_free (rule->args[arg]);

   401   rule->args[arg] = new;

   402 

   403   /* NULL termination didn't get busted */

   404   _dbus_assert (rule->args[rule->args_len] == NULL);

   405 

   406   return TRUE;

   407 }

   408 

   409 #define ISWHITE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r'))

   410 

   411 static dbus_bool_t

   412 find_key (const DBusString *str,

   413           int               start,

   414           DBusString       *key,

   415           int              *value_pos,

   416           DBusError        *error)

   417 {

   418   const char *p;

   419   const char *s;

   420   const char *key_start;

   421   const char *key_end;

   422 

   423   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   424   

   425   s = _dbus_string_get_const_data (str);

   426 

   427   p = s + start;

   428 

   429   while (*p && ISWHITE (*p))

   430     ++p;

   431 

   432   key_start = p;

   433 

   434   while (*p && *p != '=' && !ISWHITE (*p))

   435     ++p;

   436 

   437   key_end = p;

   438 

   439   while (*p && ISWHITE (*p))

   440     ++p;

   441   

   442   if (key_start == key_end)

   443     {

   444       /* Empty match rules or trailing whitespace are OK */

   445       *value_pos = p - s;

   446       return TRUE;

   447     }

   448 

   449   if (*p != '=')

   450     {

   451       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   452                       "Match rule has a key with no subsequent '=' character");

   453       return FALSE;

   454     }

   455   ++p;

   456   

   457   if (!_dbus_string_append_len (key, key_start, key_end - key_start))

   458     {

   459       BUS_SET_OOM (error);

   460       return FALSE;

   461     }

   462 

   463   *value_pos = p - s;

   464   

   465   return TRUE;

   466 }

   467 

   468 static dbus_bool_t

   469 find_value (const DBusString *str,

   470             int               start,

   471             const char       *key,

   472             DBusString       *value,

   473             int              *value_end,

   474             DBusError        *error)

   475 {

   476   const char *p;

   477   const char *s;

   478   char quote_char;

   479   int orig_len;

   480 

   481   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   482   

   483   orig_len = _dbus_string_get_length (value);

   484   

   485   s = _dbus_string_get_const_data (str);

   486 

   487   p = s + start;

   488 

   489   quote_char = '\0';

   490 

   491   while (*p)

   492     {

   493       if (quote_char == '\0')

   494         {

   495           switch (*p)

   496             {

   497             case '\0':

   498               goto done;

   499 

   500             case '\'':

   501               quote_char = '\'';

   502               goto next;

   503               

   504             case ',':

   505               ++p;

   506               goto done;

   507 

   508             case '\\':

   509               quote_char = '\\';

   510               goto next;

   511               

   512             default:

   513               if (!_dbus_string_append_byte (value, *p))

   514                 {

   515                   BUS_SET_OOM (error);

   516                   goto failed;

   517                 }

   518             }

   519         }

   520       else if (quote_char == '\\')

   521         {

   522           /* \ only counts as an escape if escaping a quote mark */

   523           if (*p != '\'')

   524             {

   525               if (!_dbus_string_append_byte (value, '\\'))

   526                 {

   527                   BUS_SET_OOM (error);

   528                   goto failed;

   529                 }

   530             }

   531 

   532           if (!_dbus_string_append_byte (value, *p))

   533             {

   534               BUS_SET_OOM (error);

   535               goto failed;

   536             }

   537           

   538           quote_char = '\0';

   539         }

   540       else

   541         {

   542           _dbus_assert (quote_char == '\'');

   543 

   544           if (*p == '\'')

   545             {

   546               quote_char = '\0';

   547             }

   548           else

   549             {

   550               if (!_dbus_string_append_byte (value, *p))

   551                 {

   552                   BUS_SET_OOM (error);

   553                   goto failed;

   554                 }

   555             }

   556         }

   557 

   558     next:

   559       ++p;

   560     }

   561 

   562  done:

   563 

   564   if (quote_char == '\\')

   565     {

   566       if (!_dbus_string_append_byte (value, '\\'))

   567         {

   568           BUS_SET_OOM (error);

   569           goto failed;

   570         }

   571     }

   572   else if (quote_char == '\'')

   573     {

   574       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   575                       "Unbalanced quotation marks in match rule");

   576       goto failed;

   577     }

   578   else

   579     _dbus_assert (quote_char == '\0');

   580 

   581   /* Zero-length values are allowed */

   582   

   583   *value_end = p - s;

   584   

   585   return TRUE;

   586 

   587  failed:

   588   _DBUS_ASSERT_ERROR_IS_SET (error);

   589   _dbus_string_set_length (value, orig_len);

   590   return FALSE;

   591 }

   592 

   593 /* duplicates aren't allowed so the real legitimate max is only 6 or

   594  * so. Leaving extra so we don't have to bother to update it.

   595  * FIXME this is sort of busted now with arg matching, but we let

   596  * you match on up to 10 args for now

   597  */

   598 #define MAX_RULE_TOKENS 16

   599 

   600 /* this is slightly too high level to be termed a "token"

   601  * but let's not be pedantic.

   602  */

   603 typedef struct

   604 {

   605   char *key;

   606   char *value;

   607 } RuleToken;

   608 

   609 static dbus_bool_t

   610 tokenize_rule (const DBusString *rule_text,

   611                RuleToken         tokens[MAX_RULE_TOKENS],

   612                DBusError        *error) 

   613 {

   614   int i;

   615   int pos;

   616   DBusString key;

   617   DBusString value;

   618   dbus_bool_t retval;

   619 

   620   retval = FALSE;

   621   

   622   if (!_dbus_string_init (&key))

   623     {

   624       BUS_SET_OOM (error);

   625       return FALSE;

   626     }

   627 

   628   if (!_dbus_string_init (&value))

   629     {

   630       _dbus_string_free (&key);

   631       BUS_SET_OOM (error);

   632       return FALSE;

   633     }

   634 

   635   i = 0;

   636   pos = 0;

   637   while (i < MAX_RULE_TOKENS &&

   638          pos < _dbus_string_get_length (rule_text))

   639     {

   640       _dbus_assert (tokens[i].key == NULL);

   641       _dbus_assert (tokens[i].value == NULL);

   642 

   643       if (!find_key (rule_text, pos, &key, &pos, error))

   644         goto out;

   645 

   646       if (_dbus_string_get_length (&key) == 0)

   647         goto next;

   648       

   649       if (!_dbus_string_steal_data (&key, &tokens[i].key))

   650         {

   651           BUS_SET_OOM (error);

   652           goto out;

   653         }

   654 

   655       if (!find_value (rule_text, pos, tokens[i].key, &value, &pos, error))

   656         goto out;

   657 

   658       if (!_dbus_string_steal_data (&value, &tokens[i].value))

   659         {

   660           BUS_SET_OOM (error);

   661           goto out;

   662         }

   663 

   664     next:

   665       ++i;

   666     }

   667 

   668   retval = TRUE;

   669   

   670  out:

   671   if (!retval)

   672     {

   673       i = 0;

   674       while (tokens[i].key || tokens[i].value)

   675         {

   676           dbus_free (tokens[i].key);

   677           dbus_free (tokens[i].value);

   678           tokens[i].key = NULL;

   679           tokens[i].value = NULL;

   680           ++i;

   681         }

   682     }

   683   

   684   _dbus_string_free (&key);

   685   _dbus_string_free (&value);

   686   

   687   return retval;

   688 }

   689 

   690 static dbus_bool_t

   691 bus_match_rule_parse_arg_match (BusMatchRule     *rule,

   692                                 const char       *key,

   693                                 const DBusString *value,

   694                                 DBusError        *error)

   695 {

   696   DBusString key_str;

   697   unsigned long arg;

   698   int end;

   699 

   700   /* For now, arg0='foo' always implies that 'foo' is a

   701    * DBUS_TYPE_STRING. Someday we could add an arg0type='int32' thing

   702    * if we wanted, which would specify another type, in which case

   703    * arg0='5' would have the 5 parsed as an int rather than string.

   704    */

   705   

   706   /* First we need to parse arg0 = 0, arg27 = 27 */

   707 

   708   _dbus_string_init_const (&key_str, key);

   709 

   710   if (_dbus_string_get_length (&key_str) < 4)

   711     {

   712       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   713                       "Key '%s' in match rule starts with 'arg' but lacks an arg number. Should be 'arg0' or 'arg7' for example.\n", key);

   714       goto failed;

   715     }

   716 

   717   if (!_dbus_string_parse_uint (&key_str, 3, &arg, &end) ||

   718       end != _dbus_string_get_length (&key_str))

   719     {

   720       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   721                       "Key '%s' in match rule starts with 'arg' but could not parse arg number. Should be 'arg0' or 'arg7' for example.\n", key);

   722       goto failed;

   723     }

   724 

   725   /* If we didn't check this we could allocate a huge amount of RAM */

   726   if (arg > DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER)

   727     {

   728       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   729                       "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);

   730       goto failed;

   731     }

   732   

   733   if ((rule->flags & BUS_MATCH_ARGS) &&

   734       rule->args_len > (int) arg &&

   735       rule->args[arg] != NULL)

   736     {

   737       dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   738                       "Key '%s' specified twice in match rule\n", key);

   739       goto failed;

   740     }

   741   

   742   if (!bus_match_rule_set_arg (rule, arg,

   743                                _dbus_string_get_const_data (value)))

   744     {

   745       BUS_SET_OOM (error);

   746       goto failed;

   747     }

   748 

   749   return TRUE;

   750 

   751  failed:

   752   _DBUS_ASSERT_ERROR_IS_SET (error);

   753   return FALSE;

   754 }

   755 

   756 /*

   757  * The format is comma-separated with strings quoted with single quotes

   758  * as for the shell (to escape a literal single quote, use '\'').

   759  *

   760  * type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='Foo',

   761  * path='/bar/foo',destination=':452345.34'

   762  *

   763  */

   764 BusMatchRule*

   765 bus_match_rule_parse (DBusConnection   *matches_go_to,

   766                       const DBusString *rule_text,

   767                       DBusError        *error)

   768 {

   769   BusMatchRule *rule;

   770   RuleToken tokens[MAX_RULE_TOKENS+1]; /* NULL termination + 1 */

   771   int i;

   772   

   773   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   774 

   775   if (_dbus_string_get_length (rule_text) > DBUS_MAXIMUM_MATCH_RULE_LENGTH)

   776     {

   777       dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,

   778                       "Match rule text is %d bytes, maximum is %d",

   779                       _dbus_string_get_length (rule_text),

   780                       DBUS_MAXIMUM_MATCH_RULE_LENGTH);

   781       return NULL;

   782     }

   783   

   784   memset (tokens, '\0', sizeof (tokens));

   785   

   786   rule = bus_match_rule_new (matches_go_to);

   787   if (rule == NULL)

   788     {

   789       BUS_SET_OOM (error);

   790       goto failed;

   791     }

   792   

   793   if (!tokenize_rule (rule_text, tokens, error))

   794     goto failed;

   795   

   796   i = 0;

   797   while (tokens[i].key != NULL)

   798     {

   799       DBusString tmp_str;

   800       int len;

   801       const char *key = tokens[i].key;

   802       const char *value = tokens[i].value;

   803       

   804       _dbus_string_init_const (&tmp_str, value);

   805       len = _dbus_string_get_length (&tmp_str);

   806 

   807       if (strcmp (key, "type") == 0)

   808         {

   809           int t;

   810 

   811           if (rule->flags & BUS_MATCH_MESSAGE_TYPE)

   812             {

   813               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   814                               "Key %s specified twice in match rule\n", key);

   815               goto failed;

   816             }

   817           

   818           t = dbus_message_type_from_string (value);

   819           

   820           if (t == DBUS_MESSAGE_TYPE_INVALID)

   821             {

   822               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   823                               "Invalid message type (%s) in match rule\n", value);

   824               goto failed;

   825             }

   826 

   827           if (!bus_match_rule_set_message_type (rule, t))

   828             {

   829               BUS_SET_OOM (error);

   830               goto failed;

   831             }

   832         }

   833       else if (strcmp (key, "sender") == 0)

   834         {

   835           if (rule->flags & BUS_MATCH_SENDER)

   836             {

   837               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   838                               "Key %s specified twice in match rule\n", key);

   839               goto failed;

   840             }

   841 

   842           if (!_dbus_validate_bus_name (&tmp_str, 0, len))

   843             {

   844               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   845                               "Sender name '%s' is invalid\n", value);

   846               goto failed;

   847             }

   848 

   849           if (!bus_match_rule_set_sender (rule, value))

   850             {

   851               BUS_SET_OOM (error);

   852               goto failed;

   853             }

   854         }

   855       else if (strcmp (key, "interface") == 0)

   856         {

   857           if (rule->flags & BUS_MATCH_INTERFACE)

   858             {

   859               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   860                               "Key %s specified twice in match rule\n", key);

   861               goto failed;

   862             }

   863 

   864           if (!_dbus_validate_interface (&tmp_str, 0, len))

   865             {

   866               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   867                               "Interface name '%s' is invalid\n", value);

   868               goto failed;

   869             }

   870 

   871           if (!bus_match_rule_set_interface (rule, value))

   872             {

   873               BUS_SET_OOM (error);

   874               goto failed;

   875             }

   876         }

   877       else if (strcmp (key, "member") == 0)

   878         {

   879           if (rule->flags & BUS_MATCH_MEMBER)

   880             {

   881               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   882                               "Key %s specified twice in match rule\n", key);

   883               goto failed;

   884             }

   885 

   886           if (!_dbus_validate_member (&tmp_str, 0, len))

   887             {

   888               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   889                               "Member name '%s' is invalid\n", value);

   890               goto failed;

   891             }

   892 

   893           if (!bus_match_rule_set_member (rule, value))

   894             {

   895               BUS_SET_OOM (error);

   896               goto failed;

   897             }

   898         }

   899       else if (strcmp (key, "path") == 0)

   900         {

   901           if (rule->flags & BUS_MATCH_PATH)

   902             {

   903               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   904                               "Key %s specified twice in match rule\n", key);

   905               goto failed;

   906             }

   907 

   908           if (!_dbus_validate_path (&tmp_str, 0, len))

   909             {

   910               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   911                               "Path '%s' is invalid\n", value);

   912               goto failed;

   913             }

   914 

   915           if (!bus_match_rule_set_path (rule, value))

   916             {

   917               BUS_SET_OOM (error);

   918               goto failed;

   919             }

   920         }

   921       else if (strcmp (key, "destination") == 0)

   922         {

   923           if (rule->flags & BUS_MATCH_DESTINATION)

   924             {

   925               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   926                               "Key %s specified twice in match rule\n", key);

   927               goto failed;

   928             }

   929 

   930           if (!_dbus_validate_bus_name (&tmp_str, 0, len))

   931             {

   932               dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   933                               "Destination name '%s' is invalid\n", value);

   934               goto failed;

   935             }

   936 

   937           if (!bus_match_rule_set_destination (rule, value))

   938             {

   939               BUS_SET_OOM (error);

   940               goto failed;

   941             }

   942         }

   943       else if (strncmp (key, "arg", 3) == 0)

   944         {

   945           if (!bus_match_rule_parse_arg_match (rule, key, &tmp_str, error))

   946             goto failed;

   947         }

   948       else

   949         {

   950           dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

   951                           "Unknown key \"%s\" in match rule",

   952                           key);

   953           goto failed;

   954         }

   955 

   956       ++i;

   957     }

   958   

   959 

   960   goto out;

   961   

   962  failed:

   963   _DBUS_ASSERT_ERROR_IS_SET (error);

   964   if (rule)

   965     {

   966       bus_match_rule_unref (rule);

   967       rule = NULL;

   968     }

   969 

   970  out:

   971   

   972   i = 0;

   973   while (tokens[i].key || tokens[i].value)

   974     {

   975       _dbus_assert (i < MAX_RULE_TOKENS);

   976       dbus_free (tokens[i].key);

   977       dbus_free (tokens[i].value);

   978       ++i;

   979     }

   980   

   981   return rule;

   982 }

   983 

   984 struct BusMatchmaker

   985 {

   986   int refcount;

   987 

   988   DBusList *all_rules;

   989 };

   990 

   991 BusMatchmaker*

   992 bus_matchmaker_new (void)

   993 {

   994   BusMatchmaker *matchmaker;

   995 

   996   matchmaker = dbus_new0 (BusMatchmaker, 1);

   997   if (matchmaker == NULL)

   998     return NULL;

   999 

  1000   matchmaker->refcount = 1;

  1001   

  1002   return matchmaker;

  1003 }

  1004 

  1005 BusMatchmaker *

  1006 bus_matchmaker_ref (BusMatchmaker *matchmaker)

  1007 {

  1008   _dbus_assert (matchmaker->refcount > 0);

  1009 

  1010   matchmaker->refcount += 1;

  1011 

  1012   return matchmaker;

  1013 }

  1014 

  1015 void

  1016 bus_matchmaker_unref (BusMatchmaker *matchmaker)

  1017 {

  1018   _dbus_assert (matchmaker->refcount > 0);

  1019 

  1020   matchmaker->refcount -= 1;

  1021   if (matchmaker->refcount == 0)

  1022     {

  1023       while (matchmaker->all_rules != NULL)

  1024         {

  1025           BusMatchRule *rule;

  1026 

  1027           rule = matchmaker->all_rules->data;

  1028           bus_match_rule_unref (rule);

  1029           _dbus_list_remove_link (&matchmaker->all_rules,

  1030                                   matchmaker->all_rules);

  1031         }

  1032 

  1033       dbus_free (matchmaker);

  1034     }

  1035 }

  1036 

  1037 /* The rule can't be modified after it's added. */

  1038 dbus_bool_t

  1039 bus_matchmaker_add_rule (BusMatchmaker   *matchmaker,

  1040                          BusMatchRule    *rule)

  1041 {

  1042   _dbus_assert (bus_connection_is_active (rule->matches_go_to));

  1043 

  1044   if (!_dbus_list_append (&matchmaker->all_rules, rule))

  1045     return FALSE;

  1046 

  1047   if (!bus_connection_add_match_rule (rule->matches_go_to, rule))

  1048     {

  1049       _dbus_list_remove_last (&matchmaker->all_rules, rule);

  1050       return FALSE;

  1051     }

  1052   

  1053   bus_match_rule_ref (rule);

  1054 

  1055 #ifdef DBUS_ENABLE_VERBOSE_MODE

  1056   {

  1057     char *s = match_rule_to_string (rule);

  1058 

  1059     _dbus_verbose ("Added match rule %s to connection %p\n",

  1060                    s, rule->matches_go_to);

  1061     dbus_free (s);

  1062   }

  1063 #endif

  1064   

  1065   return TRUE;

  1066 }

  1067 

  1068 static dbus_bool_t

  1069 match_rule_equal (BusMatchRule *a,

  1070                   BusMatchRule *b)

  1071 {

  1072   if (a->flags != b->flags)

  1073     return FALSE;

  1074 

  1075   if (a->matches_go_to != b->matches_go_to)

  1076     return FALSE;

  1077 

  1078   if ((a->flags & BUS_MATCH_MESSAGE_TYPE) &&

  1079       a->message_type != b->message_type)

  1080     return FALSE;

  1081 

  1082   if ((a->flags & BUS_MATCH_MEMBER) &&

  1083       strcmp (a->member, b->member) != 0)

  1084     return FALSE;

  1085 

  1086   if ((a->flags & BUS_MATCH_PATH) &&

  1087       strcmp (a->path, b->path) != 0)

  1088     return FALSE;

  1089   

  1090   if ((a->flags & BUS_MATCH_INTERFACE) &&

  1091       strcmp (a->interface, b->interface) != 0)

  1092     return FALSE;

  1093 

  1094   if ((a->flags & BUS_MATCH_SENDER) &&

  1095       strcmp (a->sender, b->sender) != 0)

  1096     return FALSE;

  1097 

  1098   if ((a->flags & BUS_MATCH_DESTINATION) &&

  1099       strcmp (a->destination, b->destination) != 0)

  1100     return FALSE;

  1101 

  1102   if (a->flags & BUS_MATCH_ARGS)

  1103     {

  1104       int i;

  1105       

  1106       if (a->args_len != b->args_len)

  1107         return FALSE;

  1108       

  1109       i = 0;

  1110       while (i < a->args_len)

  1111         {

  1112           if ((a->args[i] != NULL) != (b->args[i] != NULL))

  1113             return FALSE;

  1114 

  1115           if (a->args[i] != NULL)

  1116             {

  1117               _dbus_assert (b->args[i] != NULL);

  1118               if (strcmp (a->args[i], b->args[i]) != 0)

  1119                 return FALSE;

  1120             }

  1121           

  1122           ++i;

  1123         }

  1124     }

  1125   

  1126   return TRUE;

  1127 }

  1128 

  1129 static void

  1130 bus_matchmaker_remove_rule_link (BusMatchmaker   *matchmaker,

  1131                                  DBusList        *link)

  1132 {

  1133   BusMatchRule *rule = link->data;

  1134   

  1135   bus_connection_remove_match_rule (rule->matches_go_to, rule);