sl@0: /* -*- mode: C; c-file-style: "gnu" -*- */
sl@0: /* policy.c  Bus security policy
sl@0:  *
sl@0:  * Copyright (C) 2003, 2004  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: 
sl@0: #include "policy.h"
sl@0: #include "services.h"
sl@0: #include "test.h"
sl@0: #include "utils.h"
sl@0: #ifndef __SYMBIAN32__
sl@0: #include <dbus/dbus-list.h>
sl@0: #include <dbus/dbus-hash.h>
sl@0: #include <dbus/dbus-internals.h>
sl@0: #else
sl@0: #include "dbus-list.h"
sl@0: #include "dbus-hash.h"
sl@0: #include "dbus-internals.h"
sl@0: #endif //__SYMBIAN32__
sl@0: 
sl@0: BusPolicyRule*
sl@0: bus_policy_rule_new (BusPolicyRuleType type,
sl@0:                      dbus_bool_t       allow)
sl@0: {
sl@0:   BusPolicyRule *rule;
sl@0: 
sl@0:   rule = dbus_new0 (BusPolicyRule, 1);
sl@0:   if (rule == NULL)
sl@0:     return NULL;
sl@0: 
sl@0:   rule->type = type;
sl@0:   rule->refcount = 1;
sl@0:   rule->allow = allow;
sl@0: 
sl@0:   switch (rule->type)
sl@0:     {
sl@0:     case BUS_POLICY_RULE_USER:
sl@0:       rule->d.user.uid = DBUS_UID_UNSET;
sl@0:       break;
sl@0:     case BUS_POLICY_RULE_GROUP:
sl@0:       rule->d.group.gid = DBUS_GID_UNSET;
sl@0:       break;
sl@0:     case BUS_POLICY_RULE_SEND:
sl@0:       rule->d.send.message_type = DBUS_MESSAGE_TYPE_INVALID;
sl@0: 
sl@0:       /* allow rules default to TRUE (only requested replies allowed)
sl@0:        * deny rules default to FALSE (only unrequested replies denied)
sl@0:        */
sl@0:       rule->d.send.requested_reply = rule->allow;
sl@0:       break;
sl@0:     case BUS_POLICY_RULE_RECEIVE:
sl@0:       rule->d.receive.message_type = DBUS_MESSAGE_TYPE_INVALID;
sl@0:       /* allow rules default to TRUE (only requested replies allowed)
sl@0:        * deny rules default to FALSE (only unrequested replies denied)
sl@0:        */
sl@0:       rule->d.receive.requested_reply = rule->allow;
sl@0:       break;
sl@0:     case BUS_POLICY_RULE_OWN:
sl@0:       break;
sl@0:     }
sl@0:   
sl@0:   return rule;
sl@0: }
sl@0: 
sl@0: BusPolicyRule *
sl@0: bus_policy_rule_ref (BusPolicyRule *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_policy_rule_unref (BusPolicyRule *rule)
sl@0: {
sl@0:   _dbus_assert (rule->refcount > 0);
sl@0: 
sl@0:   rule->refcount -= 1;
sl@0:   
sl@0:   if (rule->refcount == 0)
sl@0:     {
sl@0:       switch (rule->type)
sl@0:         {
sl@0:         case BUS_POLICY_RULE_SEND:
sl@0:           dbus_free (rule->d.send.path);
sl@0:           dbus_free (rule->d.send.interface);
sl@0:           dbus_free (rule->d.send.member);
sl@0:           dbus_free (rule->d.send.error);
sl@0:           dbus_free (rule->d.send.destination);
sl@0:           break;
sl@0:         case BUS_POLICY_RULE_RECEIVE:
sl@0:           dbus_free (rule->d.receive.path);
sl@0:           dbus_free (rule->d.receive.interface);
sl@0:           dbus_free (rule->d.receive.member);
sl@0:           dbus_free (rule->d.receive.error);
sl@0:           dbus_free (rule->d.receive.origin);
sl@0:           break;
sl@0:         case BUS_POLICY_RULE_OWN:
sl@0:           dbus_free (rule->d.own.service_name);
sl@0:           break;
sl@0:         case BUS_POLICY_RULE_USER:
sl@0:           break;
sl@0:         case BUS_POLICY_RULE_GROUP:
sl@0:           break;
sl@0:         }
sl@0:       
sl@0:       dbus_free (rule);
sl@0:     }
sl@0: }
sl@0: 
sl@0: struct BusPolicy
sl@0: {
sl@0:   int refcount;
sl@0: 
sl@0:   DBusList *default_rules;         /**< Default policy rules */
sl@0:   DBusList *mandatory_rules;       /**< Mandatory policy rules */
sl@0:   DBusHashTable *rules_by_uid;     /**< per-UID policy rules */
sl@0:   DBusHashTable *rules_by_gid;     /**< per-GID policy rules */
sl@0:   DBusList *at_console_true_rules; /**< console user policy rules where at_console="true"*/
sl@0:   DBusList *at_console_false_rules; /**< console user policy rules where at_console="false"*/
sl@0: };
sl@0: 
sl@0: static void
sl@0: free_rule_func (void *data,
sl@0:                 void *user_data)
sl@0: {
sl@0:   BusPolicyRule *rule = data;
sl@0: 
sl@0:   bus_policy_rule_unref (rule);
sl@0: }
sl@0: 
sl@0: static void
sl@0: free_rule_list_func (void *data)
sl@0: {
sl@0:   DBusList **list = data;
sl@0: 
sl@0:   if (list == NULL) /* DBusHashTable is on crack */
sl@0:     return;
sl@0:   
sl@0:   _dbus_list_foreach (list, free_rule_func, NULL);
sl@0:   
sl@0:   _dbus_list_clear (list);
sl@0: 
sl@0:   dbus_free (list);
sl@0: }
sl@0: 
sl@0: BusPolicy*
sl@0: bus_policy_new (void)
sl@0: {
sl@0:   BusPolicy *policy;
sl@0: 
sl@0:   policy = dbus_new0 (BusPolicy, 1);
sl@0:   if (policy == NULL)
sl@0:     return NULL;
sl@0: 
sl@0:   policy->refcount = 1;
sl@0:   
sl@0:   policy->rules_by_uid = _dbus_hash_table_new (DBUS_HASH_ULONG,
sl@0:                                                NULL,
sl@0:                                                free_rule_list_func);
sl@0:   if (policy->rules_by_uid == NULL)
sl@0:     goto failed;
sl@0: 
sl@0:   policy->rules_by_gid = _dbus_hash_table_new (DBUS_HASH_ULONG,
sl@0:                                                NULL,
sl@0:                                                free_rule_list_func);
sl@0:   if (policy->rules_by_gid == NULL)
sl@0:     goto failed;
sl@0: 
sl@0:   return policy;
sl@0:   
sl@0:  failed:
sl@0:   bus_policy_unref (policy);
sl@0:   return NULL;
sl@0: }
sl@0: 
sl@0: BusPolicy *
sl@0: bus_policy_ref (BusPolicy *policy)
sl@0: {
sl@0:   _dbus_assert (policy->refcount > 0);
sl@0: 
sl@0:   policy->refcount += 1;
sl@0: 
sl@0:   return policy;
sl@0: }
sl@0: 
sl@0: void
sl@0: bus_policy_unref (BusPolicy *policy)
sl@0: {
sl@0:   _dbus_assert (policy->refcount > 0);
sl@0: 
sl@0:   policy->refcount -= 1;
sl@0: 
sl@0:   if (policy->refcount == 0)
sl@0:     {
sl@0:       _dbus_list_foreach (&policy->default_rules, free_rule_func, NULL);
sl@0:       _dbus_list_clear (&policy->default_rules);
sl@0: 
sl@0:       _dbus_list_foreach (&policy->mandatory_rules, free_rule_func, NULL);
sl@0:       _dbus_list_clear (&policy->mandatory_rules);
sl@0: 
sl@0:       _dbus_list_foreach (&policy->at_console_true_rules, free_rule_func, NULL);
sl@0:       _dbus_list_clear (&policy->at_console_true_rules);
sl@0: 
sl@0:       _dbus_list_foreach (&policy->at_console_false_rules, free_rule_func, NULL);
sl@0:       _dbus_list_clear (&policy->at_console_false_rules);
sl@0: 
sl@0:       if (policy->rules_by_uid)
sl@0:         {
sl@0:           _dbus_hash_table_unref (policy->rules_by_uid);
sl@0:           policy->rules_by_uid = NULL;
sl@0:         }
sl@0: 
sl@0:       if (policy->rules_by_gid)
sl@0:         {
sl@0:           _dbus_hash_table_unref (policy->rules_by_gid);
sl@0:           policy->rules_by_gid = NULL;
sl@0:         }
sl@0:       
sl@0:       dbus_free (policy);
sl@0:     }
sl@0: }
sl@0: 
sl@0: static dbus_bool_t
sl@0: add_list_to_client (DBusList        **list,
sl@0:                     BusClientPolicy  *client)
sl@0: {
sl@0:   DBusList *link;
sl@0: 
sl@0:   link = _dbus_list_get_first_link (list);
sl@0:   while (link != NULL)
sl@0:     {
sl@0:       BusPolicyRule *rule = link->data;
sl@0:       link = _dbus_list_get_next_link (list, link);
sl@0: 
sl@0:       switch (rule->type)
sl@0:         {
sl@0:         case BUS_POLICY_RULE_USER:
sl@0:         case BUS_POLICY_RULE_GROUP:
sl@0:           /* These aren't per-connection policies */
sl@0:           break;
sl@0: 
sl@0:         case BUS_POLICY_RULE_OWN:
sl@0:         case BUS_POLICY_RULE_SEND:
sl@0:         case BUS_POLICY_RULE_RECEIVE:
sl@0:           /* These are per-connection */
sl@0:           if (!bus_client_policy_append_rule (client, rule))
sl@0:             return FALSE;
sl@0:           break;
sl@0:         }
sl@0:     }
sl@0:   
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: BusClientPolicy*
sl@0: bus_policy_create_client_policy (BusPolicy      *policy,
sl@0:                                  DBusConnection *connection,
sl@0:                                  DBusError      *error)
sl@0: {
sl@0:   BusClientPolicy *client;
sl@0:   dbus_uid_t uid;
sl@0:   dbus_bool_t at_console;
sl@0: 
sl@0:   _dbus_assert (dbus_connection_get_is_authenticated (connection));
sl@0:   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
sl@0:   
sl@0:   client = bus_client_policy_new ();
sl@0:   if (client == NULL)
sl@0:     goto nomem;
sl@0: 
sl@0:   if (!add_list_to_client (&policy->default_rules,
sl@0:                            client))
sl@0:     goto nomem;
sl@0: 
sl@0:   /* we avoid the overhead of looking up user's groups
sl@0:    * if we don't have any group rules anyway
sl@0:    */
sl@0:   if (_dbus_hash_table_get_n_entries (policy->rules_by_gid) > 0)
sl@0:     {
sl@0:       unsigned long *groups;
sl@0:       int n_groups;
sl@0:       int i;
sl@0:       
sl@0:       if (!bus_connection_get_groups (connection, &groups, &n_groups, error))
sl@0:         goto failed;
sl@0:       
sl@0:       i = 0;
sl@0:       while (i < n_groups)
sl@0:         {
sl@0:           DBusList **list;
sl@0:           
sl@0:           list = _dbus_hash_table_lookup_ulong (policy->rules_by_gid,
sl@0:                                                 groups[i]);
sl@0:           
sl@0:           if (list != NULL)
sl@0:             {
sl@0:               if (!add_list_to_client (list, client))
sl@0:                 {
sl@0:                   dbus_free (groups);
sl@0:                   goto nomem;
sl@0:                 }
sl@0:             }
sl@0:           
sl@0:           ++i;
sl@0:         }
sl@0: 
sl@0:       dbus_free (groups);
sl@0:     }
sl@0: 
sl@0:   if (!dbus_connection_get_unix_user (connection, &uid))
sl@0:     {
sl@0:       dbus_set_error (error, DBUS_ERROR_FAILED,
sl@0:                       "No user ID known for connection, cannot determine security policy\n");
sl@0:       goto failed;
sl@0:     }
sl@0: 
sl@0:   if (_dbus_hash_table_get_n_entries (policy->rules_by_uid) > 0)
sl@0:     {
sl@0:       DBusList **list;
sl@0:       
sl@0:       list = _dbus_hash_table_lookup_ulong (policy->rules_by_uid,
sl@0:                                             uid);
sl@0: 
sl@0:       if (list != NULL)
sl@0:         {
sl@0:           if (!add_list_to_client (list, client))
sl@0:             goto nomem;
sl@0:         }
sl@0:     }
sl@0: 
sl@0:   /* Add console rules */
sl@0:   at_console = _dbus_is_console_user (uid, error);
sl@0: 
sl@0:   if (at_console)
sl@0:     {
sl@0:       if (!add_list_to_client (&policy->at_console_true_rules, client))
sl@0:         goto nomem;
sl@0:     }
sl@0:   else if (dbus_error_is_set (error) == TRUE)
sl@0:     {
sl@0:       goto failed;
sl@0:     }
sl@0:   else if (!add_list_to_client (&policy->at_console_false_rules, client))
sl@0:     {
sl@0:       goto nomem;
sl@0:     }
sl@0: 
sl@0:   if (!add_list_to_client (&policy->mandatory_rules,
sl@0:                            client))
sl@0:     goto nomem;
sl@0: 
sl@0:   bus_client_policy_optimize (client);
sl@0:   
sl@0:   return client;
sl@0: 
sl@0:  nomem:
sl@0:   BUS_SET_OOM (error);
sl@0:  failed:
sl@0:   _DBUS_ASSERT_ERROR_IS_SET (error);
sl@0:   if (client)
sl@0:     bus_client_policy_unref (client);
sl@0:   return NULL;
sl@0: }
sl@0: 
sl@0: static dbus_bool_t
sl@0: list_allows_user (dbus_bool_t           def,
sl@0:                   DBusList            **list,
sl@0:                   unsigned long         uid,
sl@0:                   const unsigned long  *group_ids,
sl@0:                   int                   n_group_ids)
sl@0: {
sl@0:   DBusList *link;
sl@0:   dbus_bool_t allowed;
sl@0:   
sl@0:   allowed = def;
sl@0: 
sl@0:   link = _dbus_list_get_first_link (list);
sl@0:   while (link != NULL)
sl@0:     {
sl@0:       BusPolicyRule *rule = link->data;
sl@0:       link = _dbus_list_get_next_link (list, link);
sl@0: 
sl@0:       if (rule->type == BUS_POLICY_RULE_USER)
sl@0:         {
sl@0:           _dbus_verbose ("List %p user rule uid="DBUS_UID_FORMAT"\n",
sl@0:                          list, rule->d.user.uid);
sl@0:           
sl@0:           if (rule->d.user.uid == DBUS_UID_UNSET)
sl@0:             ; /* '*' wildcard */
sl@0:           else if (rule->d.user.uid != uid)
sl@0:             continue;
sl@0:         }
sl@0:       else if (rule->type == BUS_POLICY_RULE_GROUP)
sl@0:         {
sl@0:           _dbus_verbose ("List %p group rule uid="DBUS_UID_FORMAT"\n",
sl@0:                          list, rule->d.user.uid);
sl@0:           
sl@0:           if (rule->d.group.gid == DBUS_GID_UNSET)
sl@0:             ;  /* '*' wildcard */
sl@0:           else
sl@0:             {
sl@0:               int i;
sl@0:               
sl@0:               i = 0;
sl@0:               while (i < n_group_ids)
sl@0:                 {
sl@0:                   if (rule->d.group.gid == group_ids[i])
sl@0:                     break;
sl@0:                   ++i;
sl@0:                 }
sl@0:               
sl@0:               if (i == n_group_ids)
sl@0:                 continue;
sl@0:             }
sl@0:         }
sl@0:       else
sl@0:         continue;
sl@0: 
sl@0:       allowed = rule->allow;
sl@0:     }
sl@0:   
sl@0:   return allowed;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_policy_allow_user (BusPolicy        *policy,
sl@0:                        DBusUserDatabase *user_database,
sl@0:                        unsigned long     uid)
sl@0: {
sl@0:   dbus_bool_t allowed;
sl@0:   unsigned long *group_ids;
sl@0:   int n_group_ids;
sl@0: 
sl@0:   /* On OOM or error we always reject the user */
sl@0:   if (!_dbus_user_database_get_groups (user_database,
sl@0:                                        uid, &group_ids, &n_group_ids, NULL))
sl@0:     {
sl@0:       _dbus_verbose ("Did not get any groups for UID %lu\n",
sl@0:                      uid);
sl@0:       return FALSE;
sl@0:     }
sl@0: 
sl@0:   /* Default to "user owning bus" or root can connect */
sl@0:   allowed = uid == _dbus_getuid ();
sl@0: 
sl@0:   allowed = list_allows_user (allowed,
sl@0:                               &policy->default_rules,
sl@0:                               uid,
sl@0:                               group_ids, n_group_ids);
sl@0: 
sl@0:   allowed = list_allows_user (allowed,
sl@0:                               &policy->mandatory_rules,
sl@0:                               uid,
sl@0:                               group_ids, n_group_ids);
sl@0: 
sl@0:   dbus_free (group_ids);
sl@0: 
sl@0:   _dbus_verbose ("UID %lu allowed = %d\n", uid, allowed);
sl@0:   
sl@0:   return allowed;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_policy_append_default_rule (BusPolicy      *policy,
sl@0:                                 BusPolicyRule  *rule)
sl@0: {
sl@0:   if (!_dbus_list_append (&policy->default_rules, rule))
sl@0:     return FALSE;
sl@0: 
sl@0:   bus_policy_rule_ref (rule);
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_policy_append_mandatory_rule (BusPolicy      *policy,
sl@0:                                   BusPolicyRule  *rule)
sl@0: {
sl@0:   if (!_dbus_list_append (&policy->mandatory_rules, rule))
sl@0:     return FALSE;
sl@0: 
sl@0:   bus_policy_rule_ref (rule);
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: 
sl@0: 
sl@0: static DBusList**
sl@0: get_list (DBusHashTable *hash,
sl@0:           unsigned long  key)
sl@0: {
sl@0:   DBusList **list;
sl@0: 
sl@0:   list = _dbus_hash_table_lookup_ulong (hash, key);
sl@0: 
sl@0:   if (list == NULL)
sl@0:     {
sl@0:       list = dbus_new0 (DBusList*, 1);
sl@0:       if (list == NULL)
sl@0:         return NULL;
sl@0: 
sl@0:       if (!_dbus_hash_table_insert_ulong (hash, key, list))
sl@0:         {
sl@0:           dbus_free (list);
sl@0:           return NULL;
sl@0:         }
sl@0:     }
sl@0: 
sl@0:   return list;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_policy_append_user_rule (BusPolicy      *policy,
sl@0:                              dbus_uid_t      uid,
sl@0:                              BusPolicyRule  *rule)
sl@0: {
sl@0:   DBusList **list;
sl@0: 
sl@0:   list = get_list (policy->rules_by_uid, uid);
sl@0: 
sl@0:   if (list == NULL)
sl@0:     return FALSE;
sl@0: 
sl@0:   if (!_dbus_list_append (list, rule))
sl@0:     return FALSE;
sl@0: 
sl@0:   bus_policy_rule_ref (rule);
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_policy_append_group_rule (BusPolicy      *policy,
sl@0:                               dbus_gid_t      gid,
sl@0:                               BusPolicyRule  *rule)
sl@0: {
sl@0:   DBusList **list;
sl@0: 
sl@0:   list = get_list (policy->rules_by_gid, gid);
sl@0: 
sl@0:   if (list == NULL)
sl@0:     return FALSE;
sl@0: 
sl@0:   if (!_dbus_list_append (list, rule))
sl@0:     return FALSE;
sl@0: 
sl@0:   bus_policy_rule_ref (rule);
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_policy_append_console_rule (BusPolicy      *policy,
sl@0:                                 dbus_bool_t     at_console,
sl@0:                                 BusPolicyRule  *rule)
sl@0: {
sl@0:   if (at_console)
sl@0:     {
sl@0:       if (!_dbus_list_append (&policy->at_console_true_rules, rule))
sl@0:         return FALSE;
sl@0:     }
sl@0:     else
sl@0:     {
sl@0:       if (!_dbus_list_append (&policy->at_console_false_rules, rule))
sl@0:         return FALSE;
sl@0:     }
sl@0: 
sl@0:   bus_policy_rule_ref (rule);
sl@0: 
sl@0:   return TRUE;
sl@0: 
sl@0: }
sl@0: 
sl@0: static dbus_bool_t
sl@0: append_copy_of_policy_list (DBusList **list,
sl@0:                             DBusList **to_append)
sl@0: {
sl@0:   DBusList *link;
sl@0:   DBusList *tmp_list;
sl@0: 
sl@0:   tmp_list = NULL;
sl@0: 
sl@0:   /* Preallocate all our links */
sl@0:   link = _dbus_list_get_first_link (to_append);
sl@0:   while (link != NULL)
sl@0:     {
sl@0:       if (!_dbus_list_append (&tmp_list, link->data))
sl@0:         {
sl@0:           _dbus_list_clear (&tmp_list);
sl@0:           return FALSE;
sl@0:         }
sl@0:       
sl@0:       link = _dbus_list_get_next_link (to_append, link);
sl@0:     }
sl@0: 
sl@0:   /* Now append them */
sl@0:   while ((link = _dbus_list_pop_first_link (&tmp_list)))
sl@0:     {
sl@0:       bus_policy_rule_ref (link->data);
sl@0:       _dbus_list_append_link (list, link);
sl@0:     }
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: static dbus_bool_t
sl@0: merge_id_hash (DBusHashTable *dest,
sl@0:                DBusHashTable *to_absorb)
sl@0: {
sl@0:   DBusHashIter iter;
sl@0:   
sl@0:   _dbus_hash_iter_init (to_absorb, &iter);
sl@0:   while (_dbus_hash_iter_next (&iter))
sl@0:     {
sl@0:       unsigned long id = _dbus_hash_iter_get_ulong_key (&iter);
sl@0:       DBusList **list = _dbus_hash_iter_get_value (&iter);
sl@0:       DBusList **target = get_list (dest, id);
sl@0: 
sl@0:       if (target == NULL)
sl@0:         return FALSE;
sl@0: 
sl@0:       if (!append_copy_of_policy_list (target, list))
sl@0:         return FALSE;
sl@0:     }
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_policy_merge (BusPolicy *policy,
sl@0:                   BusPolicy *to_absorb)
sl@0: {
sl@0:   /* FIXME Not properly atomic, but as used for configuration files we
sl@0:    * don't rely on it quite so much.
sl@0:    */
sl@0:   
sl@0:   if (!append_copy_of_policy_list (&policy->default_rules,
sl@0:                                    &to_absorb->default_rules))
sl@0:     return FALSE;
sl@0:   
sl@0:   if (!append_copy_of_policy_list (&policy->mandatory_rules,
sl@0:                                    &to_absorb->mandatory_rules))
sl@0:     return FALSE;
sl@0: 
sl@0:   if (!append_copy_of_policy_list (&policy->at_console_true_rules,
sl@0:                                    &to_absorb->at_console_true_rules))
sl@0:     return FALSE;
sl@0: 
sl@0:   if (!append_copy_of_policy_list (&policy->at_console_false_rules,
sl@0:                                    &to_absorb->at_console_false_rules))
sl@0:     return FALSE;
sl@0: 
sl@0:   if (!merge_id_hash (policy->rules_by_uid,
sl@0:                       to_absorb->rules_by_uid))
sl@0:     return FALSE;
sl@0:   
sl@0:   if (!merge_id_hash (policy->rules_by_gid,
sl@0:                       to_absorb->rules_by_gid))
sl@0:     return FALSE;
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: struct BusClientPolicy
sl@0: {
sl@0:   int refcount;
sl@0: 
sl@0:   DBusList *rules;
sl@0: };
sl@0: 
sl@0: BusClientPolicy*
sl@0: bus_client_policy_new (void)
sl@0: {
sl@0:   BusClientPolicy *policy;
sl@0: 
sl@0:   policy = dbus_new0 (BusClientPolicy, 1);
sl@0:   if (policy == NULL)
sl@0:     return NULL;
sl@0: 
sl@0:   policy->refcount = 1;
sl@0: 
sl@0:   return policy;
sl@0: }
sl@0: 
sl@0: BusClientPolicy *
sl@0: bus_client_policy_ref (BusClientPolicy *policy)
sl@0: {
sl@0:   _dbus_assert (policy->refcount > 0);
sl@0: 
sl@0:   policy->refcount += 1;
sl@0: 
sl@0:   return policy;
sl@0: }
sl@0: 
sl@0: static void
sl@0: rule_unref_foreach (void *data,
sl@0:                     void *user_data)
sl@0: {
sl@0:   BusPolicyRule *rule = data;
sl@0: 
sl@0:   bus_policy_rule_unref (rule);
sl@0: }
sl@0: 
sl@0: void
sl@0: bus_client_policy_unref (BusClientPolicy *policy)
sl@0: {
sl@0:   _dbus_assert (policy->refcount > 0);
sl@0: 
sl@0:   policy->refcount -= 1;
sl@0: 
sl@0:   if (policy->refcount == 0)
sl@0:     {
sl@0:       _dbus_list_foreach (&policy->rules,
sl@0:                           rule_unref_foreach,
sl@0:                           NULL);
sl@0: 
sl@0:       _dbus_list_clear (&policy->rules);
sl@0: 
sl@0:       dbus_free (policy);
sl@0:     }
sl@0: }
sl@0: 
sl@0: static void
sl@0: remove_rules_by_type_up_to (BusClientPolicy   *policy,
sl@0:                             BusPolicyRuleType  type,
sl@0:                             DBusList          *up_to)
sl@0: {
sl@0:   DBusList *link;
sl@0: 
sl@0:   link = _dbus_list_get_first_link (&policy->rules);
sl@0:   while (link != up_to)
sl@0:     {
sl@0:       BusPolicyRule *rule = link->data;
sl@0:       DBusList *next = _dbus_list_get_next_link (&policy->rules, link);
sl@0: 
sl@0:       if (rule->type == type)
sl@0:         {
sl@0:           _dbus_list_remove_link (&policy->rules, link);
sl@0:           bus_policy_rule_unref (rule);
sl@0:         }
sl@0:       
sl@0:       link = next;
sl@0:     }
sl@0: }
sl@0: 
sl@0: void
sl@0: bus_client_policy_optimize (BusClientPolicy *policy)
sl@0: {
sl@0:   DBusList *link;
sl@0: 
sl@0:   /* The idea here is that if we have:
sl@0:    * 
sl@0:    * <allow send_interface="foo.bar"/>
sl@0:    * <deny send_interface="*"/>
sl@0:    *
sl@0:    * (for example) the deny will always override the allow.  So we
sl@0:    * delete the allow. Ditto for deny followed by allow, etc. This is
sl@0:    * a dumb thing to put in a config file, but the <include> feature
sl@0:    * of files allows for an "inheritance and override" pattern where
sl@0:    * it could make sense. If an included file wants to "start over"
sl@0:    * with a blanket deny, no point keeping the rules from the parent
sl@0:    * file.
sl@0:    */
sl@0: 
sl@0:   _dbus_verbose ("Optimizing policy with %d rules\n",
sl@0:                  _dbus_list_get_length (&policy->rules));
sl@0:   
sl@0:   link = _dbus_list_get_first_link (&policy->rules);
sl@0:   while (link != NULL)
sl@0:     {
sl@0:       BusPolicyRule *rule;
sl@0:       DBusList *next;
sl@0:       dbus_bool_t remove_preceding;
sl@0: 
sl@0:       next = _dbus_list_get_next_link (&policy->rules, link);
sl@0:       rule = link->data;
sl@0:       
sl@0:       remove_preceding = FALSE;
sl@0: 
sl@0:       _dbus_assert (rule != NULL);
sl@0:       
sl@0:       switch (rule->type)
sl@0:         {
sl@0:         case BUS_POLICY_RULE_SEND:
sl@0:           remove_preceding =
sl@0:             rule->d.send.message_type == DBUS_MESSAGE_TYPE_INVALID &&
sl@0:             rule->d.send.path == NULL &&
sl@0:             rule->d.send.interface == NULL &&
sl@0:             rule->d.send.member == NULL &&
sl@0:             rule->d.send.error == NULL &&
sl@0:             rule->d.send.destination == NULL;
sl@0:           break;
sl@0:         case BUS_POLICY_RULE_RECEIVE:
sl@0:           remove_preceding =
sl@0:             rule->d.receive.message_type == DBUS_MESSAGE_TYPE_INVALID &&
sl@0:             rule->d.receive.path == NULL &&
sl@0:             rule->d.receive.interface == NULL &&
sl@0:             rule->d.receive.member == NULL &&
sl@0:             rule->d.receive.error == NULL &&
sl@0:             rule->d.receive.origin == NULL;
sl@0:           break;
sl@0:         case BUS_POLICY_RULE_OWN:
sl@0:           remove_preceding =
sl@0:             rule->d.own.service_name == NULL;
sl@0:           break;
sl@0:         case BUS_POLICY_RULE_USER:
sl@0:         case BUS_POLICY_RULE_GROUP:
sl@0:           _dbus_assert_not_reached ("invalid rule");
sl@0:           break;
sl@0:         }
sl@0: 
sl@0:       if (remove_preceding)
sl@0:         remove_rules_by_type_up_to (policy, rule->type,
sl@0:                                     link);
sl@0:       
sl@0:       link = next;
sl@0:     }
sl@0: 
sl@0:   _dbus_verbose ("After optimization, policy has %d rules\n",
sl@0:                  _dbus_list_get_length (&policy->rules));
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_client_policy_append_rule (BusClientPolicy *policy,
sl@0:                                BusPolicyRule   *rule)
sl@0: {
sl@0:   _dbus_verbose ("Appending rule %p with type %d to policy %p\n",
sl@0:                  rule, rule->type, policy);
sl@0:   
sl@0:   if (!_dbus_list_append (&policy->rules, rule))
sl@0:     return FALSE;
sl@0: 
sl@0:   bus_policy_rule_ref (rule);
sl@0: 
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_client_policy_check_can_send (BusClientPolicy *policy,
sl@0:                                   BusRegistry     *registry,
sl@0:                                   dbus_bool_t      requested_reply,
sl@0:                                   DBusConnection  *receiver,
sl@0:                                   DBusMessage     *message)
sl@0: {
sl@0:   DBusList *link;
sl@0:   dbus_bool_t allowed;
sl@0:   
sl@0:   /* policy->rules is in the order the rules appeared
sl@0:    * in the config file, i.e. last rule that applies wins
sl@0:    */
sl@0: 
sl@0:   _dbus_verbose ("  (policy) checking send rules\n");
sl@0:   
sl@0:   allowed = FALSE;
sl@0:   link = _dbus_list_get_first_link (&policy->rules);
sl@0:   while (link != NULL)
sl@0:     {
sl@0:       BusPolicyRule *rule = link->data;
sl@0: 
sl@0:       link = _dbus_list_get_next_link (&policy->rules, link);
sl@0:       
sl@0:       /* Rule is skipped if it specifies a different
sl@0:        * message name from the message, or a different
sl@0:        * destination from the message
sl@0:        */
sl@0:       
sl@0:       if (rule->type != BUS_POLICY_RULE_SEND)
sl@0:         {
sl@0:           _dbus_verbose ("  (policy) skipping non-send rule\n");
sl@0:           continue;
sl@0:         }
sl@0: 
sl@0:       if (rule->d.send.message_type != DBUS_MESSAGE_TYPE_INVALID)
sl@0:         {
sl@0:           if (dbus_message_get_type (message) != rule->d.send.message_type)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping rule for different message type\n");
sl@0:               continue;
sl@0:             }
sl@0:         }
sl@0: 
sl@0:       /* If it's a reply, the requested_reply flag kicks in */
sl@0:       if (dbus_message_get_reply_serial (message) != 0)
sl@0:         {
sl@0:           /* for allow, requested_reply=true means the rule applies
sl@0:            * only when reply was requested. requested_reply=false means
sl@0:            * always allow.
sl@0:            */
sl@0:           if (!requested_reply && rule->allow && rule->d.send.requested_reply)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping allow rule since it only applies to requested replies\n");
sl@0:               continue;
sl@0:             }
sl@0: 
sl@0:           /* for deny, requested_reply=false means the rule applies only
sl@0:            * when the reply was not requested. requested_reply=true means the
sl@0:            * rule always applies.
sl@0:            */
sl@0:           if (requested_reply && !rule->allow && !rule->d.send.requested_reply)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping deny rule since it only applies to unrequested replies\n");
sl@0:               continue;
sl@0:             }
sl@0:         }
sl@0:       
sl@0:       if (rule->d.send.path != NULL)
sl@0:         {
sl@0:           if (dbus_message_get_path (message) != NULL &&
sl@0:               strcmp (dbus_message_get_path (message),
sl@0:                       rule->d.send.path) != 0)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping rule for different path\n");
sl@0:               continue;
sl@0:             }
sl@0:         }
sl@0:       
sl@0:       if (rule->d.send.interface != NULL)
sl@0:         {
sl@0:           if (dbus_message_get_interface (message) != NULL &&
sl@0:               strcmp (dbus_message_get_interface (message),
sl@0:                       rule->d.send.interface) != 0)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping rule for different interface\n");
sl@0:               continue;
sl@0:             }
sl@0:         }
sl@0: 
sl@0:       if (rule->d.send.member != NULL)
sl@0:         {
sl@0:           if (dbus_message_get_member (message) != NULL &&
sl@0:               strcmp (dbus_message_get_member (message),
sl@0:                       rule->d.send.member) != 0)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping rule for different member\n");
sl@0:               continue;
sl@0:             }
sl@0:         }
sl@0: 
sl@0:       if (rule->d.send.error != NULL)
sl@0:         {
sl@0:           if (dbus_message_get_error_name (message) != NULL &&
sl@0:               strcmp (dbus_message_get_error_name (message),
sl@0:                       rule->d.send.error) != 0)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping rule for different error name\n");
sl@0:               continue;
sl@0:             }
sl@0:         }
sl@0:       
sl@0:       if (rule->d.send.destination != NULL)
sl@0:         {
sl@0:           /* receiver can be NULL for messages that are sent to the
sl@0:            * message bus itself, we check the strings in that case as
sl@0:            * built-in services don't have a DBusConnection but messages
sl@0:            * to them have a destination service name.
sl@0:            */
sl@0:           if (receiver == NULL)
sl@0:             {
sl@0:               if (!dbus_message_has_destination (message,
sl@0:                                                  rule->d.send.destination))
sl@0:                 {
sl@0:                   _dbus_verbose ("  (policy) skipping rule because message dest is not %s\n",
sl@0:                                  rule->d.send.destination);
sl@0:                   continue;
sl@0:                 }
sl@0:             }
sl@0:           else
sl@0:             {
sl@0:               DBusString str;
sl@0:               BusService *service;
sl@0:               
sl@0:               _dbus_string_init_const (&str, rule->d.send.destination);
sl@0:               
sl@0:               service = bus_registry_lookup (registry, &str);
sl@0:               if (service == NULL)
sl@0:                 {
sl@0:                   _dbus_verbose ("  (policy) skipping rule because dest %s doesn't exist\n",
sl@0:                                  rule->d.send.destination);
sl@0:                   continue;
sl@0:                 }
sl@0: 
sl@0:               if (!bus_service_has_owner (service, receiver))
sl@0:                 {
sl@0:                   _dbus_verbose ("  (policy) skipping rule because dest %s isn't owned by receiver\n",
sl@0:                                  rule->d.send.destination);
sl@0:                   continue;
sl@0:                 }
sl@0:             }
sl@0:         }
sl@0: 
sl@0:       /* Use this rule */
sl@0:       allowed = rule->allow;
sl@0: 
sl@0:       _dbus_verbose ("  (policy) used rule, allow now = %d\n",
sl@0:                      allowed);
sl@0:     }
sl@0: 
sl@0:   return allowed;
sl@0: }
sl@0: 
sl@0: /* See docs on what the args mean on bus_context_check_security_policy()
sl@0:  * comment
sl@0:  */
sl@0: dbus_bool_t
sl@0: bus_client_policy_check_can_receive (BusClientPolicy *policy,
sl@0:                                      BusRegistry     *registry,
sl@0:                                      dbus_bool_t      requested_reply,
sl@0:                                      DBusConnection  *sender,
sl@0:                                      DBusConnection  *addressed_recipient,
sl@0:                                      DBusConnection  *proposed_recipient,
sl@0:                                      DBusMessage     *message)
sl@0: {
sl@0:   DBusList *link;
sl@0:   dbus_bool_t allowed;
sl@0:   dbus_bool_t eavesdropping;
sl@0: 
sl@0:   eavesdropping =
sl@0:     addressed_recipient != proposed_recipient &&
sl@0:     dbus_message_get_destination (message) != NULL;
sl@0:   
sl@0:   /* policy->rules is in the order the rules appeared
sl@0:    * in the config file, i.e. last rule that applies wins
sl@0:    */
sl@0: 
sl@0:   _dbus_verbose ("  (policy) checking receive rules, eavesdropping = %d\n", eavesdropping);
sl@0:   
sl@0:   allowed = FALSE;
sl@0:   link = _dbus_list_get_first_link (&policy->rules);
sl@0:   while (link != NULL)
sl@0:     {
sl@0:       BusPolicyRule *rule = link->data;
sl@0: 
sl@0:       link = _dbus_list_get_next_link (&policy->rules, link);      
sl@0:       
sl@0:       if (rule->type != BUS_POLICY_RULE_RECEIVE)
sl@0:         {
sl@0:           _dbus_verbose ("  (policy) skipping non-receive rule\n");
sl@0:           continue;
sl@0:         }
sl@0: 
sl@0:       if (rule->d.receive.message_type != DBUS_MESSAGE_TYPE_INVALID)
sl@0:         {
sl@0:           if (dbus_message_get_type (message) != rule->d.receive.message_type)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping rule for different message type\n");
sl@0:               continue;
sl@0:             }
sl@0:         }
sl@0: 
sl@0:       /* for allow, eavesdrop=false means the rule doesn't apply when
sl@0:        * eavesdropping. eavesdrop=true means always allow.
sl@0:        */
sl@0:       if (eavesdropping && rule->allow && !rule->d.receive.eavesdrop)
sl@0:         {
sl@0:           _dbus_verbose ("  (policy) skipping allow rule since it doesn't apply to eavesdropping\n");
sl@0:           continue;
sl@0:         }
sl@0: 
sl@0:       /* for deny, eavesdrop=true means the rule applies only when
sl@0:        * eavesdropping; eavesdrop=false means always deny.
sl@0:        */
sl@0:       if (!eavesdropping && !rule->allow && rule->d.receive.eavesdrop)
sl@0:         {
sl@0:           _dbus_verbose ("  (policy) skipping deny rule since it only applies to eavesdropping\n");
sl@0:           continue;
sl@0:         }
sl@0: 
sl@0:       /* If it's a reply, the requested_reply flag kicks in */
sl@0:       if (dbus_message_get_reply_serial (message) != 0)
sl@0:         {
sl@0:           /* for allow, requested_reply=true means the rule applies
sl@0:            * only when reply was requested. requested_reply=false means
sl@0:            * always allow.
sl@0:            */
sl@0:           if (!requested_reply && rule->allow && rule->d.receive.requested_reply)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping allow rule since it only applies to requested replies\n");
sl@0:               continue;
sl@0:             }
sl@0: 
sl@0:           /* for deny, requested_reply=false means the rule applies only
sl@0:            * when the reply was not requested. requested_reply=true means the
sl@0:            * rule always applies.
sl@0:            */
sl@0:           if (requested_reply && !rule->allow && !rule->d.receive.requested_reply)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping deny rule since it only applies to unrequested replies\n");
sl@0:               continue;
sl@0:             }
sl@0:         }
sl@0:       
sl@0:       if (rule->d.receive.path != NULL)
sl@0:         {
sl@0:           if (dbus_message_get_path (message) != NULL &&
sl@0:               strcmp (dbus_message_get_path (message),
sl@0:                       rule->d.receive.path) != 0)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping rule for different path\n");
sl@0:               continue;
sl@0:             }
sl@0:         }
sl@0:       
sl@0:       if (rule->d.receive.interface != NULL)
sl@0:         {
sl@0:           if (dbus_message_get_interface (message) != NULL &&
sl@0:               strcmp (dbus_message_get_interface (message),
sl@0:                       rule->d.receive.interface) != 0)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping rule for different interface\n");
sl@0:               continue;
sl@0:             }
sl@0:         }      
sl@0: 
sl@0:       if (rule->d.receive.member != NULL)
sl@0:         {
sl@0:           if (dbus_message_get_member (message) != NULL &&
sl@0:               strcmp (dbus_message_get_member (message),
sl@0:                       rule->d.receive.member) != 0)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping rule for different member\n");
sl@0:               continue;
sl@0:             }
sl@0:         }
sl@0: 
sl@0:       if (rule->d.receive.error != NULL)
sl@0:         {
sl@0:           if (dbus_message_get_error_name (message) != NULL &&
sl@0:               strcmp (dbus_message_get_error_name (message),
sl@0:                       rule->d.receive.error) != 0)
sl@0:             {
sl@0:               _dbus_verbose ("  (policy) skipping rule for different error name\n");
sl@0:               continue;
sl@0:             }
sl@0:         }
sl@0:       
sl@0:       if (rule->d.receive.origin != NULL)
sl@0:         {          
sl@0:           /* sender can be NULL for messages that originate from the
sl@0:            * message bus itself, we check the strings in that case as
sl@0:            * built-in services don't have a DBusConnection but will
sl@0:            * still set the sender on their messages.
sl@0:            */
sl@0:           if (sender == NULL)
sl@0:             {
sl@0:               if (!dbus_message_has_sender (message,
sl@0:                                             rule->d.receive.origin))
sl@0:                 {
sl@0:                   _dbus_verbose ("  (policy) skipping rule because message sender is not %s\n",
sl@0:                                  rule->d.receive.origin);
sl@0:                   continue;
sl@0:                 }
sl@0:             }
sl@0:           else
sl@0:             {
sl@0:               BusService *service;
sl@0:               DBusString str;
sl@0: 
sl@0:               _dbus_string_init_const (&str, rule->d.receive.origin);
sl@0:               
sl@0:               service = bus_registry_lookup (registry, &str);
sl@0:               
sl@0:               if (service == NULL)
sl@0:                 {
sl@0:                   _dbus_verbose ("  (policy) skipping rule because origin %s doesn't exist\n",
sl@0:                                  rule->d.receive.origin);
sl@0:                   continue;
sl@0:                 }
sl@0: 
sl@0:               if (!bus_service_has_owner (service, sender))
sl@0:                 {
sl@0:                   _dbus_verbose ("  (policy) skipping rule because origin %s isn't owned by sender\n",
sl@0:                                  rule->d.receive.origin);
sl@0:                   continue;
sl@0:                 }
sl@0:             }
sl@0:         }
sl@0:       
sl@0:       /* Use this rule */
sl@0:       allowed = rule->allow;
sl@0: 
sl@0:       _dbus_verbose ("  (policy) used rule, allow now = %d\n",
sl@0:                      allowed);
sl@0:     }
sl@0: 
sl@0:   return allowed;
sl@0: }
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_client_policy_check_can_own (BusClientPolicy  *policy,
sl@0:                                  DBusConnection   *connection,
sl@0:                                  const DBusString *service_name)
sl@0: {
sl@0:   DBusList *link;
sl@0:   dbus_bool_t allowed;
sl@0:   
sl@0:   /* policy->rules is in the order the rules appeared
sl@0:    * in the config file, i.e. last rule that applies wins
sl@0:    */
sl@0: 
sl@0:   allowed = FALSE;
sl@0:   link = _dbus_list_get_first_link (&policy->rules);
sl@0:   while (link != NULL)
sl@0:     {
sl@0:       BusPolicyRule *rule = link->data;
sl@0: 
sl@0:       link = _dbus_list_get_next_link (&policy->rules, link);
sl@0:       
sl@0:       /* Rule is skipped if it specifies a different service name from
sl@0:        * the desired one.
sl@0:        */
sl@0:       
sl@0:       if (rule->type != BUS_POLICY_RULE_OWN)
sl@0:         continue;
sl@0: 
sl@0:       if (rule->d.own.service_name != NULL)
sl@0:         {
sl@0:           if (!_dbus_string_equal_c_str (service_name,
sl@0:                                          rule->d.own.service_name))
sl@0:             continue;
sl@0:         }
sl@0: 
sl@0:       /* Use this rule */
sl@0:       allowed = rule->allow;
sl@0:     }
sl@0: 
sl@0:   return allowed;
sl@0: }
sl@0: 
sl@0: #ifdef DBUS_BUILD_TESTS
sl@0: 
sl@0: dbus_bool_t
sl@0: bus_policy_test (const DBusString *test_data_dir)
sl@0: {
sl@0:   /* This doesn't do anything for now because I decided to do it in
sl@0:    * dispatch.c instead by having some of the clients in dispatch.c
sl@0:    * have particular policies applied to them.
sl@0:    */
sl@0:   
sl@0:   return TRUE;
sl@0: }
sl@0: 
sl@0: #endif /* DBUS_BUILD_TESTS */