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

/* policy.c  Bus security policy

 *

 * Copyright (C) 2003, 2004  Red Hat, Inc.

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

 * Licensed under the Academic Free License version 2.1

 * 

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

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

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

 * (at your option) any later version.

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

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

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

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

 *

 */

#include "policy.h"

#include "services.h"

#include "test.h"

#include "utils.h"

#ifndef __SYMBIAN32__

#include <dbus/dbus-list.h>

#include <dbus/dbus-hash.h>

#include <dbus/dbus-internals.h>

#else

#include "dbus-list.h"

#include "dbus-hash.h"

#include "dbus-internals.h"

#endif //__SYMBIAN32__

BusPolicyRule*

bus_policy_rule_new (BusPolicyRuleType type,

                     dbus_bool_t       allow)

{

  BusPolicyRule *rule;

  rule = dbus_new0 (BusPolicyRule, 1);

  if (rule == NULL)

    return NULL;

  rule->type = type;

  rule->refcount = 1;

  rule->allow = allow;

  switch (rule->type)

    {

    case BUS_POLICY_RULE_USER:

      rule->d.user.uid = DBUS_UID_UNSET;

      break;

    case BUS_POLICY_RULE_GROUP:

      rule->d.group.gid = DBUS_GID_UNSET;

      break;

    case BUS_POLICY_RULE_SEND:

      rule->d.send.message_type = DBUS_MESSAGE_TYPE_INVALID;

      /* allow rules default to TRUE (only requested replies allowed)

       * deny rules default to FALSE (only unrequested replies denied)

       */

      rule->d.send.requested_reply = rule->allow;

      break;

    case BUS_POLICY_RULE_RECEIVE:

      rule->d.receive.message_type = DBUS_MESSAGE_TYPE_INVALID;

      /* allow rules default to TRUE (only requested replies allowed)

       * deny rules default to FALSE (only unrequested replies denied)

       */

      rule->d.receive.requested_reply = rule->allow;

      break;

    case BUS_POLICY_RULE_OWN:

      break;

    }

  return rule;

}

BusPolicyRule *

bus_policy_rule_ref (BusPolicyRule *rule)

{

  _dbus_assert (rule->refcount > 0);

  rule->refcount += 1;

  return rule;

}

void

bus_policy_rule_unref (BusPolicyRule *rule)

{

  _dbus_assert (rule->refcount > 0);

  rule->refcount -= 1;

  if (rule->refcount == 0)

    {

      switch (rule->type)

        {

        case BUS_POLICY_RULE_SEND:

          dbus_free (rule->d.send.path);

          dbus_free (rule->d.send.interface);

          dbus_free (rule->d.send.member);

          dbus_free (rule->d.send.error);

          dbus_free (rule->d.send.destination);

          break;

        case BUS_POLICY_RULE_RECEIVE:

          dbus_free (rule->d.receive.path);

          dbus_free (rule->d.receive.interface);

          dbus_free (rule->d.receive.member);

          dbus_free (rule->d.receive.error);

          dbus_free (rule->d.receive.origin);

          break;

        case BUS_POLICY_RULE_OWN:

          dbus_free (rule->d.own.service_name);

          break;

        case BUS_POLICY_RULE_USER:

          break;

        case BUS_POLICY_RULE_GROUP:

          break;

        }

      dbus_free (rule);

    }

}

struct BusPolicy

{

  int refcount;

  DBusList *default_rules;         /**< Default policy rules */

  DBusList *mandatory_rules;       /**< Mandatory policy rules */

  DBusHashTable *rules_by_uid;     /**< per-UID policy rules */

  DBusHashTable *rules_by_gid;     /**< per-GID policy rules */

  DBusList *at_console_true_rules; /**< console user policy rules where at_console="true"*/

  DBusList *at_console_false_rules; /**< console user policy rules where at_console="false"*/

};

static void

free_rule_func (void *data,

                void *user_data)

{

  BusPolicyRule *rule = data;

  bus_policy_rule_unref (rule);

}

static void

free_rule_list_func (void *data)

{

  DBusList **list = data;

  if (list == NULL) /* DBusHashTable is on crack */

    return;

  _dbus_list_foreach (list, free_rule_func, NULL);

  _dbus_list_clear (list);

  dbus_free (list);

}

BusPolicy*

bus_policy_new (void)

{

  BusPolicy *policy;

  policy = dbus_new0 (BusPolicy, 1);

  if (policy == NULL)

    return NULL;

  policy->refcount = 1;

  policy->rules_by_uid = _dbus_hash_table_new (DBUS_HASH_ULONG,

                                               NULL,

                                               free_rule_list_func);

  if (policy->rules_by_uid == NULL)

    goto failed;

  policy->rules_by_gid = _dbus_hash_table_new (DBUS_HASH_ULONG,

                                               NULL,

                                               free_rule_list_func);

  if (policy->rules_by_gid == NULL)

    goto failed;

  return policy;

 failed:

  bus_policy_unref (policy);

  return NULL;

}

BusPolicy *

bus_policy_ref (BusPolicy *policy)

{

  _dbus_assert (policy->refcount > 0);

  policy->refcount += 1;

  return policy;

}

void

bus_policy_unref (BusPolicy *policy)

{

  _dbus_assert (policy->refcount > 0);

  policy->refcount -= 1;

  if (policy->refcount == 0)

    {

      _dbus_list_foreach (&policy->default_rules, free_rule_func, NULL);

      _dbus_list_clear (&policy->default_rules);

      _dbus_list_foreach (&policy->mandatory_rules, free_rule_func, NULL);

      _dbus_list_clear (&policy->mandatory_rules);

      _dbus_list_foreach (&policy->at_console_true_rules, free_rule_func, NULL);

      _dbus_list_clear (&policy->at_console_true_rules);

      _dbus_list_foreach (&policy->at_console_false_rules, free_rule_func, NULL);

      _dbus_list_clear (&policy->at_console_false_rules);

      if (policy->rules_by_uid)

        {

          _dbus_hash_table_unref (policy->rules_by_uid);

          policy->rules_by_uid = NULL;

        }

      if (policy->rules_by_gid)

        {

          _dbus_hash_table_unref (policy->rules_by_gid);

          policy->rules_by_gid = NULL;

        }

      dbus_free (policy);

    }

}

static dbus_bool_t

add_list_to_client (DBusList        **list,

                    BusClientPolicy  *client)

{

  DBusList *link;

  link = _dbus_list_get_first_link (list);

  while (link != NULL)

    {

      BusPolicyRule *rule = link->data;

      link = _dbus_list_get_next_link (list, link);

      switch (rule->type)

        {

        case BUS_POLICY_RULE_USER:

        case BUS_POLICY_RULE_GROUP:

          /* These aren't per-connection policies */

          break;

        case BUS_POLICY_RULE_OWN:

        case BUS_POLICY_RULE_SEND:

        case BUS_POLICY_RULE_RECEIVE:

          /* These are per-connection */

          if (!bus_client_policy_append_rule (client, rule))

            return FALSE;

          break;

        }

    }

  return TRUE;

}

BusClientPolicy*

bus_policy_create_client_policy (BusPolicy      *policy,

                                 DBusConnection *connection,

                                 DBusError      *error)

{

  BusClientPolicy *client;

  dbus_uid_t uid;

  dbus_bool_t at_console;

  _dbus_assert (dbus_connection_get_is_authenticated (connection));

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  client = bus_client_policy_new ();

  if (client == NULL)

    goto nomem;

  if (!add_list_to_client (&policy->default_rules,

                           client))

    goto nomem;

  /* we avoid the overhead of looking up user's groups

   * if we don't have any group rules anyway

   */

  if (_dbus_hash_table_get_n_entries (policy->rules_by_gid) > 0)

    {

      unsigned long *groups;

      int n_groups;

      int i;

      if (!bus_connection_get_groups (connection, &groups, &n_groups, error))

        goto failed;

      i = 0;

      while (i < n_groups)

        {

          DBusList **list;

          list = _dbus_hash_table_lookup_ulong (policy->rules_by_gid,

                                                groups[i]);

          if (list != NULL)

            {

              if (!add_list_to_client (list, client))

                {

                  dbus_free (groups);

                  goto nomem;

                }

            }

          ++i;

        }

      dbus_free (groups);

    }

  if (!dbus_connection_get_unix_user (connection, &uid))

    {

      dbus_set_error (error, DBUS_ERROR_FAILED,

                      "No user ID known for connection, cannot determine security policy\n");

      goto failed;

    }

  if (_dbus_hash_table_get_n_entries (policy->rules_by_uid) > 0)

    {

      DBusList **list;

      list = _dbus_hash_table_lookup_ulong (policy->rules_by_uid,

                                            uid);

      if (list != NULL)

        {

          if (!add_list_to_client (list, client))

            goto nomem;

        }

    }

  /* Add console rules */

  at_console = _dbus_is_console_user (uid, error);

  if (at_console)

    {

      if (!add_list_to_client (&policy->at_console_true_rules, client))

        goto nomem;

    }

  else if (dbus_error_is_set (error) == TRUE)

    {

      goto failed;

    }

  else if (!add_list_to_client (&policy->at_console_false_rules, client))

    {

      goto nomem;

    }

  if (!add_list_to_client (&policy->mandatory_rules,

                           client))

    goto nomem;

  bus_client_policy_optimize (client);

  return client;

 nomem:

  BUS_SET_OOM (error);

 failed:

  _DBUS_ASSERT_ERROR_IS_SET (error);

  if (client)

    bus_client_policy_unref (client);

  return NULL;

}

static dbus_bool_t

list_allows_user (dbus_bool_t           def,

                  DBusList            **list,

                  unsigned long         uid,

                  const unsigned long  *group_ids,

                  int                   n_group_ids)

{

  DBusList *link;

  dbus_bool_t allowed;

  allowed = def;

  link = _dbus_list_get_first_link (list);

  while (link != NULL)

    {

      BusPolicyRule *rule = link->data;

      link = _dbus_list_get_next_link (list, link);

      if (rule->type == BUS_POLICY_RULE_USER)

        {

          _dbus_verbose ("List %p user rule uid="DBUS_UID_FORMAT"\n",

                         list, rule->d.user.uid);

          if (rule->d.user.uid == DBUS_UID_UNSET)

            ; /* '*' wildcard */

          else if (rule->d.user.uid != uid)

            continue;

        }

      else if (rule->type == BUS_POLICY_RULE_GROUP)

        {

          _dbus_verbose ("List %p group rule uid="DBUS_UID_FORMAT"\n",

                         list, rule->d.user.uid);

          if (rule->d.group.gid == DBUS_GID_UNSET)

            ;  /* '*' wildcard */

          else

            {

              int i;

              i = 0;

              while (i < n_group_ids)

                {

                  if (rule->d.group.gid == group_ids[i])

                    break;

                  ++i;

                }

              if (i == n_group_ids)

                continue;

            }

        }

      else

        continue;

      allowed = rule->allow;

    }

  return allowed;

}

dbus_bool_t

bus_policy_allow_user (BusPolicy        *policy,

                       DBusUserDatabase *user_database,

                       unsigned long     uid)

{

  dbus_bool_t allowed;

  unsigned long *group_ids;

  int n_group_ids;

  /* On OOM or error we always reject the user */

  if (!_dbus_user_database_get_groups (user_database,

                                       uid, &group_ids, &n_group_ids, NULL))

    {

      _dbus_verbose ("Did not get any groups for UID %lu\n",

                     uid);

      return FALSE;

    }

  /* Default to "user owning bus" or root can connect */

  allowed = uid == _dbus_getuid ();

  allowed = list_allows_user (allowed,

                              &policy->default_rules,

                              uid,

                              group_ids, n_group_ids);

  allowed = list_allows_user (allowed,

                              &policy->mandatory_rules,

                              uid,

                              group_ids, n_group_ids);

  dbus_free (group_ids);

  _dbus_verbose ("UID %lu allowed = %d\n", uid, allowed);

  return allowed;

}

dbus_bool_t

bus_policy_append_default_rule (BusPolicy      *policy,

                                BusPolicyRule  *rule)

{

  if (!_dbus_list_append (&policy->default_rules, rule))

    return FALSE;

  bus_policy_rule_ref (rule);

  return TRUE;

}

dbus_bool_t

bus_policy_append_mandatory_rule (BusPolicy      *policy,

                                  BusPolicyRule  *rule)

{

  if (!_dbus_list_append (&policy->mandatory_rules, rule))

    return FALSE;

  bus_policy_rule_ref (rule);

  return TRUE;

}

static DBusList**

get_list (DBusHashTable *hash,

          unsigned long  key)

{

  DBusList **list;

  list = _dbus_hash_table_lookup_ulong (hash, key);

  if (list == NULL)

    {

      list = dbus_new0 (DBusList*, 1);

      if (list == NULL)

        return NULL;

      if (!_dbus_hash_table_insert_ulong (hash, key, list))

        {

          dbus_free (list);

          return NULL;

        }

    }

  return list;

}

dbus_bool_t

bus_policy_append_user_rule (BusPolicy      *policy,

                             dbus_uid_t      uid,

                             BusPolicyRule  *rule)

{

  DBusList **list;

  list = get_list (policy->rules_by_uid, uid);

  if (list == NULL)

    return FALSE;

  if (!_dbus_list_append (list, rule))

    return FALSE;

  bus_policy_rule_ref (rule);

  return TRUE;

}

dbus_bool_t

bus_policy_append_group_rule (BusPolicy      *policy,

                              dbus_gid_t      gid,

                              BusPolicyRule  *rule)

{

  DBusList **list;

  list = get_list (policy->rules_by_gid, gid);

  if (list == NULL)

    return FALSE;

  if (!_dbus_list_append (list, rule))

    return FALSE;

  bus_policy_rule_ref (rule);

  return TRUE;

}

dbus_bool_t

bus_policy_append_console_rule (BusPolicy      *policy,

                                dbus_bool_t     at_console,

                                BusPolicyRule  *rule)

{

  if (at_console)

    {

      if (!_dbus_list_append (&policy->at_console_true_rules, rule))

        return FALSE;

    }

    else

    {

      if (!_dbus_list_append (&policy->at_console_false_rules, rule))

        return FALSE;

    }

  bus_policy_rule_ref (rule);

  return TRUE;

}

static dbus_bool_t

append_copy_of_policy_list (DBusList **list,

                            DBusList **to_append)

{

  DBusList *link;

  DBusList *tmp_list;

  tmp_list = NULL;

  /* Preallocate all our links */

  link = _dbus_list_get_first_link (to_append);

  while (link != NULL)

    {

      if (!_dbus_list_append (&tmp_list, link->data))

        {

          _dbus_list_clear (&tmp_list);

          return FALSE;

        }

      link = _dbus_list_get_next_link (to_append, link);

    }

  /* Now append them */

  while ((link = _dbus_list_pop_first_link (&tmp_list)))

    {

      bus_policy_rule_ref (link->data);

      _dbus_list_append_link (list, link);

    }

  return TRUE;

}

static dbus_bool_t

merge_id_hash (DBusHashTable *dest,

               DBusHashTable *to_absorb)

{

  DBusHashIter iter;

  _dbus_hash_iter_init (to_absorb, &iter);

  while (_dbus_hash_iter_next (&iter))

    {

      unsigned long id = _dbus_hash_iter_get_ulong_key (&iter);

      DBusList **list = _dbus_hash_iter_get_value (&iter);

      DBusList **target = get_list (dest, id);

      if (target == NULL)

        return FALSE;

      if (!append_copy_of_policy_list (target, list))

        return FALSE;

    }

  return TRUE;

}

dbus_bool_t

bus_policy_merge (BusPolicy *policy,

                  BusPolicy *to_absorb)

{

  /* FIXME Not properly atomic, but as used for configuration files we

   * don't rely on it quite so much.

   */

  if (!append_copy_of_policy_list (&policy->default_rules,

                                   &to_absorb->default_rules))

    return FALSE;

  if (!append_copy_of_policy_list (&policy->mandatory_rules,

                                   &to_absorb->mandatory_rules))

    return FALSE;

  if (!append_copy_of_policy_list (&policy->at_console_true_rules,

                                   &to_absorb->at_console_true_rules))

    return FALSE;

  if (!append_copy_of_policy_list (&policy->at_console_false_rules,

                                   &to_absorb->at_console_false_rules))

    return FALSE;

  if (!merge_id_hash (policy->rules_by_uid,

                      to_absorb->rules_by_uid))

    return FALSE;

  if (!merge_id_hash (policy->rules_by_gid,

                      to_absorb->rules_by_gid))

    return FALSE;

  return TRUE;

}

struct BusClientPolicy

{

  int refcount;

  DBusList *rules;

};

BusClientPolicy*

bus_client_policy_new (void)

{

  BusClientPolicy *policy;

  policy = dbus_new0 (BusClientPolicy, 1);

  if (policy == NULL)

    return NULL;

  policy->refcount = 1;

  return policy;

}

BusClientPolicy *

bus_client_policy_ref (BusClientPolicy *policy)

{

  _dbus_assert (policy->refcount > 0);

  policy->refcount += 1;

  return policy;

}

static void

rule_unref_foreach (void *data,

                    void *user_data)

{

  BusPolicyRule *rule = data;

  bus_policy_rule_unref (rule);

}

void

bus_client_policy_unref (BusClientPolicy *policy)

{

  _dbus_assert (policy->refcount > 0);

  policy->refcount -= 1;

  if (policy->refcount == 0)

    {

      _dbus_list_foreach (&policy->rules,

                          rule_unref_foreach,

                          NULL);

      _dbus_list_clear (&policy->rules);

      dbus_free (policy);

    }

}

static void

remove_rules_by_type_up_to (BusClientPolicy   *policy,

                            BusPolicyRuleType  type,

                            DBusList          *up_to)

{

  DBusList *link;

  link = _dbus_list_get_first_link (&policy->rules);

  while (link != up_to)

    {

      BusPolicyRule *rule = link->data;

      DBusList *next = _dbus_list_get_next_link (&policy->rules, link);

      if (rule->type == type)

        {

          _dbus_list_remove_link (&policy->rules, link);

          bus_policy_rule_unref (rule);

        }

      link = next;

    }

}

void

bus_client_policy_optimize (BusClientPolicy *policy)

{

  DBusList *link;

  /* The idea here is that if we have:

   * 

   * <allow send_interface="foo.bar"/>

   * <deny send_interface="*"/>

   *

   * (for example) the deny will always override the allow.  So we

   * delete the allow. Ditto for deny followed by allow, etc. This is

   * a dumb thing to put in a config file, but the <include> feature

   * of files allows for an "inheritance and override" pattern where

   * it could make sense. If an included file wants to "start over"

   * with a blanket deny, no point keeping the rules from the parent

   * file.

   */

  _dbus_verbose ("Optimizing policy with %d rules\n",

                 _dbus_list_get_length (&policy->rules));

  link = _dbus_list_get_first_link (&policy->rules);

  while (link != NULL)

    {

      BusPolicyRule *rule;

      DBusList *next;

      dbus_bool_t remove_preceding;

      next = _dbus_list_get_next_link (&policy->rules, link);

      rule = link->data;

      remove_preceding = FALSE;

      _dbus_assert (rule != NULL);

      switch (rule->type)

        {

        case BUS_POLICY_RULE_SEND:

          remove_preceding =

            rule->d.send.message_type == DBUS_MESSAGE_TYPE_INVALID &&

            rule->d.send.path == NULL &&

            rule->d.send.interface == NULL &&

            rule->d.send.member == NULL &&

            rule->d.send.error == NULL &&

            rule->d.send.destination == NULL;

          break;

        case BUS_POLICY_RULE_RECEIVE:

          remove_preceding =

            rule->d.receive.message_type == DBUS_MESSAGE_TYPE_INVALID &&

            rule->d.receive.path == NULL &&

            rule->d.receive.interface == NULL &&

            rule->d.receive.member == NULL &&

            rule->d.receive.error == NULL &&

            rule->d.receive.origin == NULL;

          break;

        case BUS_POLICY_RULE_OWN:

          remove_preceding =

            rule->d.own.service_name == NULL;

          break;

        case BUS_POLICY_RULE_USER:

        case BUS_POLICY_RULE_GROUP:

          _dbus_assert_not_reached ("invalid rule");

          break;

        }

      if (remove_preceding)

        remove_rules_by_type_up_to (policy, rule->type,

                                    link);

      link = next;

    }

  _dbus_verbose ("After optimization, policy has %d rules\n",

                 _dbus_list_get_length (&policy->rules));

}

dbus_bool_t

bus_client_policy_append_rule (BusClientPolicy *policy,

                               BusPolicyRule   *rule)

{

  _dbus_verbose ("Appending rule %p with type %d to policy %p\n",

                 rule, rule->type, policy);

  if (!_dbus_list_append (&policy->rules, rule))

    return FALSE;

  bus_policy_rule_ref (rule);

  return TRUE;

}

dbus_bool_t

bus_client_policy_check_can_send (BusClientPolicy *policy,

                                  BusRegistry     *registry,

                                  dbus_bool_t      requested_reply,

                                  DBusConnection  *receiver,

                                  DBusMessage     *message)

{

  DBusList *link;

  dbus_bool_t allowed;

  /* policy->rules is in the order the rules appeared

   * in the config file, i.e. last rule that applies wins

   */

  _dbus_verbose ("  (policy) checking send rules\n");

  allowed = FALSE;

  link = _dbus_list_get_first_link (&policy->rules);

  while (link != NULL)

    {

      BusPolicyRule *rule = link->data;

      link = _dbus_list_get_next_link (&policy->rules, link);

      /* Rule is skipped if it specifies a different

       * message name from the message, or a different

       * destination from the message

       */

      if (rule->type != BUS_POLICY_RULE_SEND)

        {

          _dbus_verbose ("  (policy) skipping non-send rule\n");

          continue;

        }

      if (rule->d.send.message_type != DBUS_MESSAGE_TYPE_INVALID)

        {

          if (dbus_message_get_type (message) != rule->d.send.message_type)

            {

              _dbus_verbose ("  (policy) skipping rule for different message type\n");

              continue;

            }

        }

      /* If it's a reply, the requested_reply flag kicks in */

      if (dbus_message_get_reply_serial (message) != 0)

        {

          /* for allow, requested_reply=true means the rule applies

           * only when reply was requested. requested_reply=false means

           * always allow.

           */

          if (!requested_reply && rule->allow && rule->d.send.requested_reply)

            {

              _dbus_verbose ("  (policy) skipping allow rule since it only applies to requested replies\n");

              continue;

            }

          /* for deny, requested_reply=false means the rule applies only

           * when the reply was not requested. requested_reply=true means the

           * rule always applies.

           */

          if (requested_reply && !rule->allow && !rule->d.send.requested_reply)

            {

              _dbus_verbose ("  (policy) skipping deny rule since it only applies to unrequested replies\n");

              continue;

            }

        }

      if (rule->d.send.path != NULL)

        {

          if (dbus_message_get_path (message) != NULL &&

              strcmp (dbus_message_get_path (message),

                      rule->d.send.path) != 0)

            {

              _dbus_verbose ("  (policy) skipping rule for different path\n");

              continue;

            }

        }

      if (rule->d.send.interface != NULL)

        {

          if (dbus_message_get_interface (message) != NULL &&

              strcmp (dbus_message_get_interface (message),

                      rule->d.send.interface) != 0)

            {

              _dbus_verbose ("  (policy) skipping rule for different interface\n");

              continue;

            }

        }

      if (rule->d.send.member != NULL)

        {

          if (dbus_message_get_member (message) != NULL &&

              strcmp (dbus_message_get_member (message),

                      rule->d.send.member) != 0)

            {

              _dbus_verbose ("  (policy) skipping rule for different member\n");

              continue;

            }

        }

      if (rule->d.send.error != NULL)

        {

          if (dbus_message_get_error_name (message) != NULL &&

              strcmp (dbus_message_get_error_name (message),

                      rule->d.send.error) != 0)

            {

              _dbus_verbose ("  (policy) skipping rule for different error name\n");

              continue;

            }

        }

      if (rule->d.send.destination != NULL)

        {

          /* receiver can be NULL for messages that are sent to the

           * message bus itself, we check the strings in that case as

           * built-in services don't have a DBusConnection but messages

           * to them have a destination service name.

           */

          if (receiver == NULL)

            {

              if (!dbus_message_has_destination (message,

                                                 rule->d.send.destination))

                {

                  _dbus_verbose ("  (policy) skipping rule because message dest is not %s\n",

                                 rule->d.send.destination);

                  continue;

                }

            }

          else

            {

              DBusString str;

              BusService *service;

              _dbus_string_init_const (&str, rule->d.send.destination);