bus.c revision 68a3c593b9e77b33614726363c7b6fd85d113021 
1/* -*- mode: C; c-file-style: "gnu" -*- */
2/* bus.c  message bus context object
3 *
4 * Copyright (C) 2003 Red Hat, Inc.
5 *
6 * Licensed under the Academic Free License version 1.2
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
24#include "bus.h"
25#include "activation.h"
26#include "connection.h"
27#include "services.h"
28#include "utils.h"
29#include "policy.h"
30#include "config-parser.h"
31#include <dbus/dbus-list.h>
32#include <dbus/dbus-hash.h>
33#include <dbus/dbus-internals.h>
34
35struct BusContext
36{
37  int refcount;
38  char *type;
39  char *address;
40  char *pidfile;
41  DBusLoop *loop;
42  DBusList *servers;
43  BusConnections *connections;
44  BusActivation *activation;
45  BusRegistry *registry;
46  BusPolicy *policy;
47  DBusUserDatabase *user_database;
48  BusLimits limits;
49};
50
51static dbus_int32_t server_data_slot = -1;
52
53typedef struct
54{
55  BusContext *context;
56} BusServerData;
57
58#define BUS_SERVER_DATA(server) (dbus_server_get_data ((server), server_data_slot))
59
60static BusContext*
61server_get_context (DBusServer *server)
62{
63  BusContext *context;
64  BusServerData *bd;
65
66  if (!dbus_server_allocate_data_slot (&server_data_slot))
67    return NULL;
68
69  bd = BUS_SERVER_DATA (server);
70  if (bd == NULL)
71    {
72      dbus_server_free_data_slot (&server_data_slot);
73      return NULL;
74    }
75
76  context = bd->context;
77
78  dbus_server_free_data_slot (&server_data_slot);
79
80  return context;
81}
82
83static dbus_bool_t
84server_watch_callback (DBusWatch     *watch,
85                       unsigned int   condition,
86                       void          *data)
87{
88  /* FIXME this can be done in dbus-mainloop.c
89   * if the code in activation.c for the babysitter
90   * watch handler is fixed.
91   */
92
93  return dbus_watch_handle (watch, condition);
94}
95
96static dbus_bool_t
97add_server_watch (DBusWatch  *watch,
98                  void       *data)
99{
100  DBusServer *server = data;
101  BusContext *context;
102
103  context = server_get_context (server);
104
105  return _dbus_loop_add_watch (context->loop,
106                               watch, server_watch_callback, server,
107                               NULL);
108}
109
110static void
111remove_server_watch (DBusWatch  *watch,
112                     void       *data)
113{
114  DBusServer *server = data;
115  BusContext *context;
116
117  context = server_get_context (server);
118
119  _dbus_loop_remove_watch (context->loop,
120                           watch, server_watch_callback, server);
121}
122
123
124static void
125server_timeout_callback (DBusTimeout   *timeout,
126                         void          *data)
127{
128  /* can return FALSE on OOM but we just let it fire again later */
129  dbus_timeout_handle (timeout);
130}
131
132static dbus_bool_t
133add_server_timeout (DBusTimeout *timeout,
134                    void        *data)
135{
136  DBusServer *server = data;
137  BusContext *context;
138
139  context = server_get_context (server);
140
141  return _dbus_loop_add_timeout (context->loop,
142                                 timeout, server_timeout_callback, server, NULL);
143}
144
145static void
146remove_server_timeout (DBusTimeout *timeout,
147                       void        *data)
148{
149  DBusServer *server = data;
150  BusContext *context;
151
152  context = server_get_context (server);
153
154  _dbus_loop_remove_timeout (context->loop,
155                             timeout, server_timeout_callback, server);
156}
157
158static void
159new_connection_callback (DBusServer     *server,
160                         DBusConnection *new_connection,
161                         void           *data)
162{
163  BusContext *context = data;
164
165  if (!bus_connections_setup_connection (context->connections, new_connection))
166    {
167      _dbus_verbose ("No memory to setup new connection\n");
168
169      /* if we don't do this, it will get unref'd without
170       * being disconnected... kind of strange really
171       * that we have to do this, people won't get it right
172       * in general.
173       */
174      dbus_connection_disconnect (new_connection);
175    }
176
177  dbus_connection_set_max_received_size (new_connection,
178                                         context->limits.max_incoming_bytes);
179
180  dbus_connection_set_max_message_size (new_connection,
181                                        context->limits.max_message_size);
182
183  /* on OOM, we won't have ref'd the connection so it will die. */
184}
185
186static void
187free_server_data (void *data)
188{
189  BusServerData *bd = data;
190
191  dbus_free (bd);
192}
193
194static dbus_bool_t
195setup_server (BusContext *context,
196              DBusServer *server,
197              char      **auth_mechanisms,
198              DBusError  *error)
199{
200  BusServerData *bd;
201
202  bd = dbus_new0 (BusServerData, 1);
203  if (!dbus_server_set_data (server,
204                             server_data_slot,
205                             bd, free_server_data))
206    {
207      dbus_free (bd);
208      BUS_SET_OOM (error);
209      return FALSE;
210    }
211
212  bd->context = context;
213
214  if (!dbus_server_set_auth_mechanisms (server, (const char**) auth_mechanisms))
215    {
216      BUS_SET_OOM (error);
217      return FALSE;
218    }
219
220  dbus_server_set_new_connection_function (server,
221                                           new_connection_callback,
222                                           context, NULL);
223
224  if (!dbus_server_set_watch_functions (server,
225                                        add_server_watch,
226                                        remove_server_watch,
227                                        NULL,
228                                        server,
229                                        NULL))
230    {
231      BUS_SET_OOM (error);
232      return FALSE;
233    }
234
235  if (!dbus_server_set_timeout_functions (server,
236                                          add_server_timeout,
237                                          remove_server_timeout,
238                                          NULL,
239                                          server, NULL))
240    {
241      BUS_SET_OOM (error);
242      return FALSE;
243    }
244
245  return TRUE;
246}
247
248BusContext*
249bus_context_new (const DBusString *config_file,
250                 dbus_bool_t       force_fork,
251                 int               print_addr_fd,
252                 int               print_pid_fd,
253                 DBusError        *error)
254{
255  BusContext *context;
256  DBusList *link;
257  DBusList **addresses;
258  BusConfigParser *parser;
259  DBusString full_address;
260  const char *user, *pidfile;
261  char **auth_mechanisms;
262  DBusList **auth_mechanisms_list;
263  int len;
264
265  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
266
267  if (!_dbus_string_init (&full_address))
268    {
269      BUS_SET_OOM (error);
270      return NULL;
271    }
272
273  if (!dbus_server_allocate_data_slot (&server_data_slot))
274    {
275      BUS_SET_OOM (error);
276      _dbus_string_free (&full_address);
277      return NULL;
278    }
279
280  parser = NULL;
281  context = NULL;
282  auth_mechanisms = NULL;
283
284  parser = bus_config_load (config_file, TRUE, error);
285  if (parser == NULL)
286    goto failed;
287
288  /* Check for an existing pid file. Of course this is a race;
289   * we'd have to use fcntl() locks on the pid file to
290   * avoid that. But we want to check for the pid file
291   * before overwriting any existing sockets, etc.
292   */
293  pidfile = bus_config_parser_get_pidfile (parser);
294  if (pidfile != NULL)
295    {
296      DBusString u;
297      DBusStat stbuf;
298      DBusError tmp_error;
299
300      dbus_error_init (&tmp_error);
301      _dbus_string_init_const (&u, pidfile);
302
303      if (_dbus_stat (&u, &stbuf, &tmp_error))
304	{
305	  dbus_set_error (error, DBUS_ERROR_FAILED,
306			  "The pid file \"%s\" exists, if the message bus is not running, remove this file",
307			  pidfile);
308	  dbus_error_free (&tmp_error);
309	  goto failed;
310	}
311    }
312
313  context = dbus_new0 (BusContext, 1);
314  if (context == NULL)
315    {
316      BUS_SET_OOM (error);
317      goto failed;
318    }
319
320  context->refcount = 1;
321
322  /* get our limits and timeout lengths */
323  bus_config_parser_get_limits (parser, &context->limits);
324
325  /* we need another ref of the server data slot for the context
326   * to own
327   */
328  if (!dbus_server_allocate_data_slot (&server_data_slot))
329    _dbus_assert_not_reached ("second ref of server data slot failed");
330
331  context->user_database = _dbus_user_database_new ();
332  if (context->user_database == NULL)
333    {
334      BUS_SET_OOM (error);
335      goto failed;
336    }
337
338  context->loop = _dbus_loop_new ();
339  if (context->loop == NULL)
340    {
341      BUS_SET_OOM (error);
342      goto failed;
343    }
344
345  /* Build an array of auth mechanisms */
346
347  auth_mechanisms_list = bus_config_parser_get_mechanisms (parser);
348  len = _dbus_list_get_length (auth_mechanisms_list);
349
350  if (len > 0)
351    {
352      int i;
353
354      auth_mechanisms = dbus_new0 (char*, len + 1);
355      if (auth_mechanisms == NULL)
356        goto failed;
357
358      i = 0;
359      link = _dbus_list_get_first_link (auth_mechanisms_list);
360      while (link != NULL)
361        {
362          auth_mechanisms[i] = _dbus_strdup (link->data);
363          if (auth_mechanisms[i] == NULL)
364            goto failed;
365          link = _dbus_list_get_next_link (auth_mechanisms_list, link);
366        }
367    }
368  else
369    {
370      auth_mechanisms = NULL;
371    }
372
373  /* Listen on our addresses */
374
375  addresses = bus_config_parser_get_addresses (parser);
376
377  link = _dbus_list_get_first_link (addresses);
378  while (link != NULL)
379    {
380      DBusServer *server;
381
382      server = dbus_server_listen (link->data, error);
383      if (server == NULL)
384        goto failed;
385      else if (!setup_server (context, server, auth_mechanisms, error))
386        goto failed;
387
388      if (!_dbus_list_append (&context->servers, server))
389        {
390          BUS_SET_OOM (error);
391          goto failed;
392        }
393
394      link = _dbus_list_get_next_link (addresses, link);
395    }
396
397  /* note that type may be NULL */
398  context->type = _dbus_strdup (bus_config_parser_get_type (parser));
399
400  /* We have to build the address backward, so that
401   * <listen> later in the config file have priority
402   */
403  link = _dbus_list_get_last_link (&context->servers);
404  while (link != NULL)
405    {
406      char *addr;
407
408      addr = dbus_server_get_address (link->data);
409      if (addr == NULL)
410        {
411          BUS_SET_OOM (error);
412          goto failed;
413        }
414
415      if (_dbus_string_get_length (&full_address) > 0)
416        {
417          if (!_dbus_string_append (&full_address, ";"))
418            {
419              BUS_SET_OOM (error);
420              goto failed;
421            }
422        }
423
424      if (!_dbus_string_append (&full_address, addr))
425        {
426          BUS_SET_OOM (error);
427          goto failed;
428        }
429
430      dbus_free (addr);
431
432      link = _dbus_list_get_prev_link (&context->servers, link);
433    }
434
435  if (!_dbus_string_copy_data (&full_address, &context->address))
436    {
437      BUS_SET_OOM (error);
438      goto failed;
439    }
440
441  /* Note that we don't know whether the print_addr_fd is
442   * one of the sockets we're using to listen on, or some
443   * other random thing. But I think the answer is "don't do
444   * that then"
445   */
446  if (print_addr_fd >= 0)
447    {
448      DBusString addr;
449      const char *a = bus_context_get_address (context);
450      int bytes;
451
452      _dbus_assert (a != NULL);
453      if (!_dbus_string_init (&addr))
454        {
455          BUS_SET_OOM (error);
456          goto failed;
457        }
458
459      if (!_dbus_string_append (&addr, a) ||
460          !_dbus_string_append (&addr, "\n"))
461        {
462          _dbus_string_free (&addr);
463          BUS_SET_OOM (error);
464          goto failed;
465        }
466
467      bytes = _dbus_string_get_length (&addr);
468      if (_dbus_write (print_addr_fd, &addr, 0, bytes) != bytes)
469        {
470          dbus_set_error (error, DBUS_ERROR_FAILED,
471                          "Printing message bus address: %s\n",
472                          _dbus_strerror (errno));
473          _dbus_string_free (&addr);
474          goto failed;
475        }
476
477      if (print_addr_fd > 2)
478        _dbus_close (print_addr_fd, NULL);
479
480      _dbus_string_free (&addr);
481    }
482
483  /* Create activation subsystem */
484
485  context->activation = bus_activation_new (context, &full_address,
486                                            bus_config_parser_get_service_dirs (parser),
487                                            error);
488  if (context->activation == NULL)
489    {
490      _DBUS_ASSERT_ERROR_IS_SET (error);
491      goto failed;
492    }
493
494  context->connections = bus_connections_new (context);
495  if (context->connections == NULL)
496    {
497      BUS_SET_OOM (error);
498      goto failed;
499    }
500
501  context->registry = bus_registry_new (context);
502  if (context->registry == NULL)
503    {
504      BUS_SET_OOM (error);
505      goto failed;
506    }
507
508  context->policy = bus_config_parser_steal_policy (parser);
509  _dbus_assert (context->policy != NULL);
510
511  /* Now become a daemon if appropriate */
512  if (force_fork || bus_config_parser_get_fork (parser))
513    {
514      DBusString u;
515
516      if (pidfile)
517        _dbus_string_init_const (&u, pidfile);
518
519      if (!_dbus_become_daemon (pidfile ? &u : NULL, error))
520        goto failed;
521    }
522  else
523    {
524      /* Need to write PID file for ourselves, not for the child process */
525      if (pidfile != NULL)
526        {
527          DBusString u;
528
529          _dbus_string_init_const (&u, pidfile);
530
531          if (!_dbus_write_pid_file (&u, _dbus_getpid (), error))
532            goto failed;
533        }
534    }
535
536  /* keep around the pid filename so we can delete it later */
537  context->pidfile = _dbus_strdup (pidfile);
538
539  /* Write PID if requested */
540  if (print_pid_fd >= 0)
541    {
542      DBusString pid;
543      int bytes;
544
545      if (!_dbus_string_init (&pid))
546        {
547          BUS_SET_OOM (error);
548          goto failed;
549        }
550
551      if (!_dbus_string_append_int (&pid, _dbus_getpid ()) ||
552          !_dbus_string_append (&pid, "\n"))
553        {
554          _dbus_string_free (&pid);
555          BUS_SET_OOM (error);
556          goto failed;
557        }
558
559      bytes = _dbus_string_get_length (&pid);
560      if (_dbus_write (print_pid_fd, &pid, 0, bytes) != bytes)
561        {
562          dbus_set_error (error, DBUS_ERROR_FAILED,
563                          "Printing message bus PID: %s\n",
564                          _dbus_strerror (errno));
565          _dbus_string_free (&pid);
566          goto failed;
567        }
568
569      if (print_pid_fd > 2)
570        _dbus_close (print_pid_fd, NULL);
571
572      _dbus_string_free (&pid);
573    }
574
575  /* Here we change our credentials if required,
576   * as soon as we've set up our sockets and pidfile
577   */
578  user = bus_config_parser_get_user (parser);
579  if (user != NULL)
580    {
581      DBusCredentials creds;
582      DBusString u;
583
584      _dbus_string_init_const (&u, user);
585
586      if (!_dbus_credentials_from_username (&u, &creds) ||
587          creds.uid < 0 ||
588          creds.gid < 0)
589        {
590          dbus_set_error (error, DBUS_ERROR_FAILED,
591                          "Could not get UID and GID for username \"%s\"",
592                          user);
593          goto failed;
594        }
595
596      if (!_dbus_change_identity (creds.uid, creds.gid, error))
597        goto failed;
598    }
599
600  bus_config_parser_unref (parser);
601  _dbus_string_free (&full_address);
602  dbus_free_string_array (auth_mechanisms);
603  dbus_server_free_data_slot (&server_data_slot);
604
605  return context;
606
607 failed:
608  if (parser != NULL)
609    bus_config_parser_unref (parser);
610
611  if (context != NULL)
612    bus_context_unref (context);
613
614  _dbus_string_free (&full_address);
615  dbus_free_string_array (auth_mechanisms);
616
617  dbus_server_free_data_slot (&server_data_slot);
618
619  return NULL;
620}
621
622static void
623shutdown_server (BusContext *context,
624                 DBusServer *server)
625{
626  if (server == NULL ||
627      !dbus_server_get_is_connected (server))
628    return;
629
630  if (!dbus_server_set_watch_functions (server,
631                                        NULL, NULL, NULL,
632                                        context,
633                                        NULL))
634    _dbus_assert_not_reached ("setting watch functions to NULL failed");
635
636  if (!dbus_server_set_timeout_functions (server,
637                                          NULL, NULL, NULL,
638                                          context,
639                                          NULL))
640    _dbus_assert_not_reached ("setting timeout functions to NULL failed");
641
642  dbus_server_disconnect (server);
643}
644
645void
646bus_context_shutdown (BusContext  *context)
647{
648  DBusList *link;
649
650  link = _dbus_list_get_first_link (&context->servers);
651  while (link != NULL)
652    {
653      shutdown_server (context, link->data);
654
655      link = _dbus_list_get_next_link (&context->servers, link);
656    }
657}
658
659void
660bus_context_ref (BusContext *context)
661{
662  _dbus_assert (context->refcount > 0);
663  context->refcount += 1;
664}
665
666void
667bus_context_unref (BusContext *context)
668{
669  _dbus_assert (context->refcount > 0);
670  context->refcount -= 1;
671
672  if (context->refcount == 0)
673    {
674      DBusList *link;
675
676      _dbus_verbose ("Finalizing bus context %p\n", context);
677
678      bus_context_shutdown (context);
679
680      if (context->connections)
681        {
682          bus_connections_unref (context->connections);
683          context->connections = NULL;
684        }
685
686      if (context->registry)
687        {
688          bus_registry_unref (context->registry);
689          context->registry = NULL;
690        }
691
692      if (context->activation)
693        {
694          bus_activation_unref (context->activation);
695          context->activation = NULL;
696        }
697
698      link = _dbus_list_get_first_link (&context->servers);
699      while (link != NULL)
700        {
701          dbus_server_unref (link->data);
702
703          link = _dbus_list_get_next_link (&context->servers, link);
704        }
705      _dbus_list_clear (&context->servers);
706
707      if (context->policy)
708        {
709          bus_policy_unref (context->policy);
710          context->policy = NULL;
711        }
712
713      if (context->loop)
714        {
715          _dbus_loop_unref (context->loop);
716          context->loop = NULL;
717        }
718
719      dbus_free (context->type);
720      dbus_free (context->address);
721
722      if (context->pidfile)
723	{
724          DBusString u;
725          _dbus_string_init_const (&u, context->pidfile);
726
727          /* Deliberately ignore errors here, since there's not much
728	   * we can do about it, and we're exiting anyways.
729	   */
730	  _dbus_delete_file (&u, NULL);
731
732          dbus_free (context->pidfile);
733	}
734
735      _dbus_user_database_unref (context->user_database);
736
737      dbus_free (context);
738
739      dbus_server_free_data_slot (&server_data_slot);
740    }
741}
742
743/* type may be NULL */
744const char*
745bus_context_get_type (BusContext *context)
746{
747  return context->type;
748}
749
750const char*
751bus_context_get_address (BusContext *context)
752{
753  return context->address;
754}
755
756BusRegistry*
757bus_context_get_registry (BusContext  *context)
758{
759  return context->registry;
760}
761
762BusConnections*
763bus_context_get_connections (BusContext  *context)
764{
765  return context->connections;
766}
767
768BusActivation*
769bus_context_get_activation (BusContext  *context)
770{
771  return context->activation;
772}
773
774DBusLoop*
775bus_context_get_loop (BusContext *context)
776{
777  return context->loop;
778}
779
780DBusUserDatabase*
781bus_context_get_user_database (BusContext *context)
782{
783  return context->user_database;
784}
785
786dbus_bool_t
787bus_context_allow_user (BusContext   *context,
788                        unsigned long uid)
789{
790  return bus_policy_allow_user (context->policy,
791                                context->user_database,
792                                uid);
793}
794
795BusClientPolicy*
796bus_context_create_client_policy (BusContext      *context,
797                                  DBusConnection  *connection,
798                                  DBusError       *error)
799{
800  _DBUS_ASSERT_ERROR_IS_CLEAR (error);
801  return bus_policy_create_client_policy (context->policy, connection,
802                                          error);
803}
804
805int
806bus_context_get_activation_timeout (BusContext *context)
807{
808
809  return context->limits.activation_timeout;
810}
811
812int
813bus_context_get_auth_timeout (BusContext *context)
814{
815  return context->limits.auth_timeout;
816}
817
818int
819bus_context_get_max_completed_connections (BusContext *context)
820{
821  return context->limits.max_completed_connections;
822}
823
824int
825bus_context_get_max_incomplete_connections (BusContext *context)
826{
827  return context->limits.max_incomplete_connections;
828}
829
830int
831bus_context_get_max_connections_per_user (BusContext *context)
832{
833  return context->limits.max_connections_per_user;
834}
835
836int
837bus_context_get_max_pending_activations (BusContext *context)
838{
839  return context->limits.max_pending_activations;
840}
841
842int
843bus_context_get_max_services_per_connection (BusContext *context)
844{
845  return context->limits.max_services_per_connection;
846}
847
848dbus_bool_t
849bus_context_check_security_policy (BusContext     *context,
850                                   DBusConnection *sender,
851                                   DBusConnection *recipient,
852                                   DBusMessage    *message,
853                                   DBusError      *error)
854{
855  BusClientPolicy *sender_policy;
856  BusClientPolicy *recipient_policy;
857
858  /* NULL sender/receiver means the bus driver */
859
860  if (sender != NULL)
861    {
862      if (bus_connection_is_active (sender))
863        {
864          sender_policy = bus_connection_get_policy (sender);
865          _dbus_assert (sender_policy != NULL);
866        }
867      else
868        {
869          /* Policy for inactive connections is that they can only send
870           * the hello message to the bus driver
871           */
872          if (recipient == NULL &&
873              dbus_message_is_method_call (message,
874                                           DBUS_INTERFACE_ORG_FREEDESKTOP_DBUS,
875                                           "Hello"))
876            {
877              _dbus_verbose ("security check allowing %s message\n",
878                             "Hello");
879              return TRUE;
880            }
881          else
882            {
883              _dbus_verbose ("security check disallowing non-%s message\n",
884                             "Hello");
885
886              dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
887                              "Client tried to send a message other than %s without being registered",
888                              "Hello");
889
890              return FALSE;
891            }
892        }
893    }
894  else
895    sender_policy = NULL;
896
897  _dbus_assert ((sender != NULL && sender_policy != NULL) ||
898                (sender == NULL && sender_policy == NULL));
899
900  if (recipient != NULL)
901    {
902      /* only the bus driver can send to an inactive recipient (as it
903       * owns no services, so other apps can't address it). Inactive
904       * recipients can receive any message.
905       */
906      if (bus_connection_is_active (recipient))
907        {
908          recipient_policy = bus_connection_get_policy (recipient);
909          _dbus_assert (recipient_policy != NULL);
910        }
911      else if (sender == NULL)
912        {
913          _dbus_verbose ("security check using NULL recipient policy for message from bus\n");
914          recipient_policy = NULL;
915        }
916      else
917        {
918          _dbus_assert_not_reached ("a message was somehow sent to an inactive recipient from a source other than the message bus\n");
919          recipient_policy = NULL;
920        }
921    }
922  else
923    recipient_policy = NULL;
924
925  _dbus_assert ((recipient != NULL && recipient_policy != NULL) ||
926                (recipient != NULL && sender == NULL && recipient_policy == NULL) ||
927                (recipient == NULL && recipient_policy == NULL));
928
929  if (sender_policy &&
930      !bus_client_policy_check_can_send (sender_policy,
931                                         context->registry, recipient,
932                                         message))
933    {
934      const char *dest = dbus_message_get_destination (message);
935      dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
936                      "A security policy in place prevents this sender "
937                      "from sending this message to this recipient, "
938                      "see message bus configuration file (rejected message "
939                      "had interface \"%s\" member \"%s\" error name \"%s\" destination \"%s\")",
940                      dbus_message_get_interface (message) ?
941                      dbus_message_get_interface (message) : "(unset)",
942                      dbus_message_get_member (message) ?
943                      dbus_message_get_member (message) : "(unset)",
944                      dbus_message_get_error_name (message) ?
945                      dbus_message_get_error_name (message) : "(unset)",
946                      dest ? dest : DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
947      _dbus_verbose ("security policy disallowing message due to sender policy\n");
948      return FALSE;
949    }
950
951  if (recipient_policy &&
952      !bus_client_policy_check_can_receive (recipient_policy,
953                                            context->registry, sender,
954                                            message))
955    {
956      const char *dest = dbus_message_get_destination (message);
957      dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
958                      "A security policy in place prevents this recipient "
959                      "from receiving this message from this sender, "
960                      "see message bus configuration file (rejected message "
961                      "had interface \"%s\" member \"%s\" error name \"%s\" destination \"%s\")",
962                      dbus_message_get_interface (message) ?
963                      dbus_message_get_interface (message) : "(unset)",
964                      dbus_message_get_member (message) ?
965                      dbus_message_get_member (message) : "(unset)",
966                      dbus_message_get_error_name (message) ?
967                      dbus_message_get_error_name (message) : "(unset)",
968                      dest ? dest : DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
969      _dbus_verbose ("security policy disallowing message due to recipient policy\n");
970      return FALSE;
971    }
972
973  /* See if limits on size have been exceeded */
974  if (recipient &&
975      dbus_connection_get_outgoing_size (recipient) >
976      context->limits.max_outgoing_bytes)
977    {
978      const char *dest = dbus_message_get_destination (message);
979      dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,
980                      "The destination service \"%s\" has a full message queue",
981                      dest ? dest : DBUS_SERVICE_ORG_FREEDESKTOP_DBUS);
982      _dbus_verbose ("security policy disallowing message due to full message queue\n");
983      return FALSE;
984    }
985
986  _dbus_verbose ("security policy allowing message\n");
987  return TRUE;
988}
989