[lib-fix] fixed sending broadcasts bigger than memfd threshold
[platform/upstream/dbus.git] / bus / bus.c
1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2 /* bus.c  message bus context object
3  *
4  * Copyright (C) 2003, 2004 Red Hat, Inc.
5  * Copyright (C) 2013  Samsung Electronics
6  *
7  * Licensed under the Academic Free License version 2.1
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
22  *
23  */
24
25 #include <config.h>
26 #include "bus.h"
27
28 #include <stdio.h>
29
30 #include "activation.h"
31 #include "connection.h"
32 #include "services.h"
33 #include "utils.h"
34 #include "policy.h"
35 #include "config-parser.h"
36 #include "signals.h"
37 #include "selinux.h"
38 #include "dir-watch.h"
39 #include <dbus/dbus-list.h>
40 #include <dbus/dbus-hash.h>
41 #include <dbus/dbus-credentials.h>
42 #include <dbus/dbus-internals.h>
43
44 #ifdef ENABLE_KDBUS_TRANSPORT
45 #include "kdbus-d.h"
46 #include <stdlib.h>
47 #endif
48
49 #ifdef DBUS_CYGWIN
50 #include <signal.h>
51 #endif
52
53 struct BusContext
54 {
55   int refcount;
56   DBusGUID uuid;
57   char *config_file;
58   char *type;
59   char *servicehelper;
60   char *address;
61   char *pidfile;
62   char *user;
63   char *log_prefix;
64   DBusLoop *loop;
65   DBusList *servers;
66   BusConnections *connections;
67   BusActivation *activation;
68   BusRegistry *registry;
69   BusPolicy *policy;
70   BusMatchmaker *matchmaker;
71   BusLimits limits;
72   unsigned int fork : 1;
73   unsigned int syslog : 1;
74   unsigned int keep_umask : 1;
75   unsigned int allow_anonymous : 1;
76   unsigned int systemd_activation : 1;
77 #ifdef ENABLE_KDBUS_TRANSPORT
78   DBusConnection *myKdbusConnection;  //todo maybe can be rafctored and removed
79 #endif
80 };
81
82 static dbus_int32_t server_data_slot = -1;
83
84 typedef struct
85 {
86   BusContext *context;
87 } BusServerData;
88
89 #define BUS_SERVER_DATA(server) (dbus_server_get_data ((server), server_data_slot))
90
91 static BusContext*
92 server_get_context (DBusServer *server)
93 {
94   BusContext *context;
95   BusServerData *bd;
96
97   if (!dbus_server_allocate_data_slot (&server_data_slot))
98     return NULL;
99
100   bd = BUS_SERVER_DATA (server);
101   if (bd == NULL)
102     {
103       dbus_server_free_data_slot (&server_data_slot);
104       return NULL;
105     }
106
107   context = bd->context;
108
109   dbus_server_free_data_slot (&server_data_slot);
110
111   return context;
112 }
113
114 static dbus_bool_t
115 add_server_watch (DBusWatch  *watch,
116                   void       *data)
117 {
118   DBusServer *server = data;
119   BusContext *context;
120
121   context = server_get_context (server);
122
123   return _dbus_loop_add_watch (context->loop, watch);
124 }
125
126 static void
127 remove_server_watch (DBusWatch  *watch,
128                      void       *data)
129 {
130   DBusServer *server = data;
131   BusContext *context;
132
133   context = server_get_context (server);
134
135   _dbus_loop_remove_watch (context->loop, watch);
136 }
137
138 static void
139 toggle_server_watch (DBusWatch  *watch,
140                      void       *data)
141 {
142   DBusServer *server = data;
143   BusContext *context;
144
145   context = server_get_context (server);
146
147   _dbus_loop_toggle_watch (context->loop, watch);
148 }
149
150 static dbus_bool_t
151 add_server_timeout (DBusTimeout *timeout,
152                     void        *data)
153 {
154   DBusServer *server = data;
155   BusContext *context;
156
157   context = server_get_context (server);
158
159   return _dbus_loop_add_timeout (context->loop, timeout);
160 }
161
162 static void
163 remove_server_timeout (DBusTimeout *timeout,
164                        void        *data)
165 {
166   DBusServer *server = data;
167   BusContext *context;
168
169   context = server_get_context (server);
170
171   _dbus_loop_remove_timeout (context->loop, timeout);
172 }
173
174 static void
175 new_connection_callback (DBusServer     *server,
176                          DBusConnection *new_connection,
177                          void           *data)
178 {
179   BusContext *context = data;
180
181   if (!bus_connections_setup_connection (context->connections, new_connection))
182     {
183       _dbus_verbose ("No memory to setup new connection\n");
184
185       /* if we don't do this, it will get unref'd without
186        * being disconnected... kind of strange really
187        * that we have to do this, people won't get it right
188        * in general.
189        */
190       dbus_connection_close (new_connection);
191     }
192
193   dbus_connection_set_max_received_size (new_connection,
194                                          context->limits.max_incoming_bytes);
195
196   dbus_connection_set_max_message_size (new_connection,
197                                         context->limits.max_message_size);
198
199   dbus_connection_set_max_received_unix_fds (new_connection,
200                                          context->limits.max_incoming_unix_fds);
201
202   dbus_connection_set_max_message_unix_fds (new_connection,
203                                         context->limits.max_message_unix_fds);
204
205   dbus_connection_set_allow_anonymous (new_connection,
206                                        context->allow_anonymous);
207
208   /* on OOM, we won't have ref'd the connection so it will die. */
209 }
210
211 static void
212 free_server_data (void *data)
213 {
214   BusServerData *bd = data;
215
216   dbus_free (bd);
217 }
218
219 static dbus_bool_t
220 setup_server (BusContext *context,
221               DBusServer *server,
222               char      **auth_mechanisms,
223               DBusError  *error)
224 {
225   BusServerData *bd;
226
227   bd = dbus_new0 (BusServerData, 1);
228   if (bd == NULL || !dbus_server_set_data (server,
229                                            server_data_slot,
230                                            bd, free_server_data))
231     {
232       dbus_free (bd);
233       BUS_SET_OOM (error);
234       return FALSE;
235     }
236
237   bd->context = context;
238
239   if (!dbus_server_set_auth_mechanisms (server, (const char**) auth_mechanisms))
240     {
241       BUS_SET_OOM (error);
242       return FALSE;
243     }
244
245   dbus_server_set_new_connection_function (server,
246                                            new_connection_callback,
247                                            context, NULL);
248
249   if (!dbus_server_set_watch_functions (server,
250                                         add_server_watch,
251                                         remove_server_watch,
252                                         toggle_server_watch,
253                                         server,
254                                         NULL))
255     {
256       BUS_SET_OOM (error);
257       return FALSE;
258     }
259
260   if (!dbus_server_set_timeout_functions (server,
261                                           add_server_timeout,
262                                           remove_server_timeout,
263                                           NULL,
264                                           server, NULL))
265     {
266       BUS_SET_OOM (error);
267       return FALSE;
268     }
269
270   return TRUE;
271 }
272
273 /* This code only gets executed the first time the
274  * config files are parsed.  It is not executed
275  * when config files are reloaded.
276  */
277 static dbus_bool_t
278 process_config_first_time_only (BusContext       *context,
279                                 BusConfigParser  *parser,
280                                 const DBusString *address,
281                                 BusContextFlags   flags,
282                                 DBusError        *error)
283 {
284   DBusString log_prefix;
285   DBusList *link;
286   DBusList **addresses;
287   const char *user, *pidfile;
288   char **auth_mechanisms;
289   DBusList **auth_mechanisms_list;
290   int len;
291   dbus_bool_t retval;
292
293   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
294
295   retval = FALSE;
296   auth_mechanisms = NULL;
297   pidfile = NULL;
298
299   _dbus_init_system_log (TRUE);
300
301   if (flags & BUS_CONTEXT_FLAG_SYSTEMD_ACTIVATION)
302     context->systemd_activation = TRUE;
303   else
304     context->systemd_activation = FALSE;
305
306   /* Check for an existing pid file. Of course this is a race;
307    * we'd have to use fcntl() locks on the pid file to
308    * avoid that. But we want to check for the pid file
309    * before overwriting any existing sockets, etc.
310    */
311
312   if (flags & BUS_CONTEXT_FLAG_WRITE_PID_FILE)
313     pidfile = bus_config_parser_get_pidfile (parser);
314
315   if (pidfile != NULL)
316     {
317       DBusString u;
318       DBusStat stbuf;
319
320       _dbus_string_init_const (&u, pidfile);
321
322       if (_dbus_stat (&u, &stbuf, NULL))
323         {
324 #ifdef DBUS_CYGWIN
325           DBusString p;
326           long /* int */ pid;
327
328           _dbus_string_init (&p);
329           _dbus_file_get_contents(&p, &u, NULL);
330           _dbus_string_parse_int(&p, 0, &pid, NULL);
331           _dbus_string_free(&p);
332
333           if ((kill((int)pid, 0))) {
334             dbus_set_error(NULL, DBUS_ERROR_FILE_EXISTS,
335                            "pid %ld not running, removing stale pid file\n",
336                            pid);
337             _dbus_delete_file(&u, NULL);
338           } else {
339 #endif
340           dbus_set_error (error, DBUS_ERROR_FAILED,
341                                   "The pid file \"%s\" exists, if the message bus is not running, remove this file",
342                           pidfile);
343               goto failed;
344 #ifdef DBUS_CYGWIN
345           }
346 #endif
347         }
348     }
349
350   /* keep around the pid filename so we can delete it later */
351   context->pidfile = _dbus_strdup (pidfile);
352
353   /* note that type may be NULL */
354   context->type = _dbus_strdup (bus_config_parser_get_type (parser));
355   if (bus_config_parser_get_type (parser) != NULL && context->type == NULL)
356     goto oom;
357
358   user = bus_config_parser_get_user (parser);
359   if (user != NULL)
360     {
361       context->user = _dbus_strdup (user);
362       if (context->user == NULL)
363         goto oom;
364     }
365
366   /* Set up the prefix for syslog messages */
367   if (!_dbus_string_init (&log_prefix))
368     goto oom;
369   if (context->type && !strcmp (context->type, "system"))
370     {
371       if (!_dbus_string_append (&log_prefix, "[system] "))
372         goto oom;
373     }
374   else if (context->type && !strcmp (context->type, "session"))
375     {
376       DBusCredentials *credentials;
377
378       credentials = _dbus_credentials_new_from_current_process ();
379       if (!credentials)
380         goto oom;
381       if (!_dbus_string_append (&log_prefix, "[session "))
382         {
383           _dbus_credentials_unref (credentials);
384           goto oom;
385         }
386       if (!_dbus_credentials_to_string_append (credentials, &log_prefix))
387         {
388           _dbus_credentials_unref (credentials);
389           goto oom;
390         }
391       if (!_dbus_string_append (&log_prefix, "] "))
392         {
393           _dbus_credentials_unref (credentials);
394           goto oom;
395         }
396       _dbus_credentials_unref (credentials);
397     }
398   if (!_dbus_string_steal_data (&log_prefix, &context->log_prefix))
399     goto oom;
400   _dbus_string_free (&log_prefix);
401
402   /* Build an array of auth mechanisms */
403
404   auth_mechanisms_list = bus_config_parser_get_mechanisms (parser);
405   len = _dbus_list_get_length (auth_mechanisms_list);
406
407   if (len > 0)
408     {
409       int i;
410
411       auth_mechanisms = dbus_new0 (char*, len + 1);
412       if (auth_mechanisms == NULL)
413         goto oom;
414
415       i = 0;
416       link = _dbus_list_get_first_link (auth_mechanisms_list);
417       while (link != NULL)
418         {
419           auth_mechanisms[i] = _dbus_strdup (link->data);
420           if (auth_mechanisms[i] == NULL)
421             goto oom;
422           link = _dbus_list_get_next_link (auth_mechanisms_list, link);
423           i += 1;
424         }
425     }
426   else
427     {
428       auth_mechanisms = NULL;
429     }
430
431   /* Listen on our addresses */
432
433   if (address)
434     {
435 #ifdef ENABLE_KDBUS_TRANSPORT
436       if(!strcmp(_dbus_string_get_const_data(address), "kdbus:"))
437       {
438           DBusBusType type;
439           DBusServer* server;
440           char* bus_address;
441
442           if(!strcmp (context->type, "system"))
443                   type = DBUS_BUS_SYSTEM;
444           else if(!strcmp (context->type, "session"))
445                   type = DBUS_BUS_SESSION;
446           else
447                   type = DBUS_BUS_STARTER;
448
449           bus_address = make_kdbus_bus(type, error);
450           if(bus_address == NULL)
451                   goto failed;
452
453           server = empty_server_init(bus_address);
454           if(server == NULL)
455           {
456                   free(bus_address);
457                   goto failed;
458           }
459
460           if (!_dbus_list_append (&context->servers, server))
461           {
462                   free(bus_address);
463                   goto oom;
464           }
465
466           context->myKdbusConnection = daemon_as_client(type, bus_address, error);
467           if(context->myKdbusConnection == NULL)
468                   goto failed;
469       }
470       else
471 #endif
472         {
473                   DBusServer *server;
474
475                   server = dbus_server_listen (_dbus_string_get_const_data(address), error);
476                   if (server == NULL)
477                         {
478                           _DBUS_ASSERT_ERROR_IS_SET (error);
479                           goto failed;
480                         }
481                   else if (!setup_server (context, server, auth_mechanisms, error))
482                         {
483                           _DBUS_ASSERT_ERROR_IS_SET (error);
484                           goto failed;
485                         }
486
487                   if (!_dbus_list_append (&context->servers, server))
488                         goto oom;
489       }
490     }
491   else
492     {
493       addresses = bus_config_parser_get_addresses (parser);
494
495       link = _dbus_list_get_first_link (addresses);
496       while (link != NULL)
497         {
498           DBusServer *server;
499
500           server = dbus_server_listen (link->data, error);
501           if (server == NULL)
502             {
503               _DBUS_ASSERT_ERROR_IS_SET (error);
504               goto failed;
505             }
506           else if (!setup_server (context, server, auth_mechanisms, error))
507             {
508               _DBUS_ASSERT_ERROR_IS_SET (error);
509               goto failed;
510             }
511
512           if (!_dbus_list_append (&context->servers, server))
513             goto oom;
514
515           link = _dbus_list_get_next_link (addresses, link);
516         }
517     }
518
519   context->fork = bus_config_parser_get_fork (parser);
520   context->syslog = bus_config_parser_get_syslog (parser);
521   context->keep_umask = bus_config_parser_get_keep_umask (parser);
522   context->allow_anonymous = bus_config_parser_get_allow_anonymous (parser);
523
524   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
525   retval = TRUE;
526
527  failed:
528   dbus_free_string_array (auth_mechanisms);
529   return retval;
530
531  oom:
532   BUS_SET_OOM (error);
533   dbus_free_string_array (auth_mechanisms);
534   return FALSE;
535 }
536
537 /* This code gets executed every time the config files
538  * are parsed: both during BusContext construction
539  * and on reloads. This function is slightly screwy
540  * since it can do a "half reload" in out-of-memory
541  * situations. Realistically, unlikely to ever matter.
542  */
543 static dbus_bool_t
544 process_config_every_time (BusContext      *context,
545                            BusConfigParser *parser,
546                            dbus_bool_t      is_reload,
547                            DBusError       *error)
548 {
549   DBusString full_address;
550   DBusList *link;
551   DBusList **dirs;
552   char *addr;
553   const char *servicehelper;
554   char *s;
555
556   dbus_bool_t retval;
557
558   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
559
560   addr = NULL;
561   retval = FALSE;
562
563   if (!_dbus_string_init (&full_address))
564     {
565       BUS_SET_OOM (error);
566       return FALSE;
567     }
568
569   /* get our limits and timeout lengths */
570   bus_config_parser_get_limits (parser, &context->limits);
571
572   if (context->policy)
573     bus_policy_unref (context->policy);
574   context->policy = bus_config_parser_steal_policy (parser);
575   _dbus_assert (context->policy != NULL);
576
577   /* We have to build the address backward, so that
578    * <listen> later in the config file have priority
579    */
580   link = _dbus_list_get_last_link (&context->servers);
581   while (link != NULL)
582     {
583       addr = dbus_server_get_address (link->data);
584       if (addr == NULL)
585         {
586           BUS_SET_OOM (error);
587           goto failed;
588         }
589
590       if (_dbus_string_get_length (&full_address) > 0)
591         {
592           if (!_dbus_string_append (&full_address, ";"))
593             {
594               BUS_SET_OOM (error);
595               goto failed;
596             }
597         }
598
599       if (!_dbus_string_append (&full_address, addr))
600         {
601           BUS_SET_OOM (error);
602           goto failed;
603         }
604
605       dbus_free (addr);
606       addr = NULL;
607
608       link = _dbus_list_get_prev_link (&context->servers, link);
609     }
610
611   if (is_reload)
612     dbus_free (context->address);
613
614   if (!_dbus_string_copy_data (&full_address, &context->address))
615     {
616       BUS_SET_OOM (error);
617       goto failed;
618     }
619
620   /* get the service directories */
621   dirs = bus_config_parser_get_service_dirs (parser);
622
623   /* and the service helper */
624   servicehelper = bus_config_parser_get_servicehelper (parser);
625
626   s = _dbus_strdup(servicehelper);
627   if (s == NULL && servicehelper != NULL)
628     {
629       BUS_SET_OOM (error);
630       goto failed;
631     }
632   else
633     {
634       dbus_free(context->servicehelper);
635       context->servicehelper = s;
636     }
637
638   /* Create activation subsystem */
639   if (context->activation)
640     {
641       if (!bus_activation_reload (context->activation, &full_address, dirs, error))
642         goto failed;
643     }
644   else
645     {
646       context->activation = bus_activation_new (context, &full_address, dirs, error);
647     }
648
649   if (context->activation == NULL)
650     {
651       _DBUS_ASSERT_ERROR_IS_SET (error);
652       goto failed;
653     }
654
655   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
656   retval = TRUE;
657
658  failed:
659   _dbus_string_free (&full_address);
660
661   if (addr)
662     dbus_free (addr);
663
664   return retval;
665 }
666
667 static dbus_bool_t
668 list_concat_new (DBusList **a,
669                  DBusList **b,
670                  DBusList **result)
671 {
672   DBusList *link;
673
674   *result = NULL;
675
676   for (link = _dbus_list_get_first_link (a); link; link = _dbus_list_get_next_link (a, link))
677     {
678       if (!_dbus_list_append (result, link->data))
679         goto oom;
680     }
681   for (link = _dbus_list_get_first_link (b); link; link = _dbus_list_get_next_link (b, link))
682     {
683       if (!_dbus_list_append (result, link->data))
684         goto oom;
685     }
686
687   return TRUE;
688 oom:
689   _dbus_list_clear (result);
690   return FALSE;
691 }
692
693 static void
694 raise_file_descriptor_limit (BusContext      *context)
695 {
696
697   /* I just picked this out of thin air; we need some extra
698    * descriptors for things like any internal pipes we create,
699    * inotify, connections to SELinux, etc.
700    */
701   unsigned int arbitrary_extra_fds = 32;
702   unsigned int limit;
703
704   limit = context->limits.max_completed_connections +
705     context->limits.max_incomplete_connections
706     + arbitrary_extra_fds;
707
708   _dbus_request_file_descriptor_limit (limit);
709 }
710
711 static dbus_bool_t
712 process_config_postinit (BusContext      *context,
713                          BusConfigParser *parser,
714                          DBusError       *error)
715 {
716   DBusHashTable *service_context_table;
717   DBusList *watched_dirs = NULL;
718
719   raise_file_descriptor_limit (context);
720
721   service_context_table = bus_config_parser_steal_service_context_table (parser);
722   if (!bus_registry_set_service_context_table (context->registry,
723                                                service_context_table))
724     {
725       BUS_SET_OOM (error);
726       return FALSE;
727     }
728
729   _dbus_hash_table_unref (service_context_table);
730
731   /* We need to monitor both the configuration directories and directories
732    * containing .service files.
733    */
734   if (!list_concat_new (bus_config_parser_get_conf_dirs (parser),
735                         bus_config_parser_get_service_dirs (parser),
736                         &watched_dirs))
737     {
738       BUS_SET_OOM (error);
739       return FALSE;
740     }
741
742   bus_set_watched_dirs (context, &watched_dirs);
743
744   _dbus_list_clear (&watched_dirs);
745
746   return TRUE;
747 }
748
749 BusContext*
750 bus_context_new (const DBusString *config_file,
751                  BusContextFlags   flags,
752                  DBusPipe         *print_addr_pipe,
753                  DBusPipe         *print_pid_pipe,
754                  const DBusString *address,
755                  DBusError        *error)
756 {
757   BusContext *context;
758   BusConfigParser *parser;
759
760   _dbus_assert ((flags & BUS_CONTEXT_FLAG_FORK_NEVER) == 0 ||
761                 (flags & BUS_CONTEXT_FLAG_FORK_ALWAYS) == 0);
762
763   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
764
765   context = NULL;
766   parser = NULL;
767
768   if (!dbus_server_allocate_data_slot (&server_data_slot))
769     {
770       BUS_SET_OOM (error);
771       return NULL;
772     }
773
774   context = dbus_new0 (BusContext, 1);
775   if (context == NULL)
776     {
777       BUS_SET_OOM (error);
778       goto failed;
779     }
780   context->refcount = 1;
781
782 #ifdef ENABLE_KDBUS_TRANSPORT
783   context->myKdbusConnection = NULL;
784 #endif
785
786   _dbus_generate_uuid (&context->uuid);
787
788   if (!_dbus_string_copy_data (config_file, &context->config_file))
789     {
790       BUS_SET_OOM (error);
791       goto failed;
792     }
793
794   context->loop = _dbus_loop_new ();
795   if (context->loop == NULL)
796     {
797       BUS_SET_OOM (error);
798       goto failed;
799     }
800
801   context->registry = bus_registry_new (context);
802   if (context->registry == NULL)
803     {
804       BUS_SET_OOM (error);
805       goto failed;
806     }
807
808   parser = bus_config_load (config_file, TRUE, NULL, error);
809   if (parser == NULL)
810     {
811       _DBUS_ASSERT_ERROR_IS_SET (error);
812       goto failed;
813     }
814
815   if (!process_config_first_time_only (context, parser, address, flags, error))
816     {
817       _DBUS_ASSERT_ERROR_IS_SET (error);
818       goto failed;
819     }
820   if (!process_config_every_time (context, parser, FALSE, error))
821     {
822       _DBUS_ASSERT_ERROR_IS_SET (error);
823       goto failed;
824     }
825
826   /* we need another ref of the server data slot for the context
827    * to own
828    */
829   if (!dbus_server_allocate_data_slot (&server_data_slot))
830     _dbus_assert_not_reached ("second ref of server data slot failed");
831
832   /* Note that we don't know whether the print_addr_pipe is
833    * one of the sockets we're using to listen on, or some
834    * other random thing. But I think the answer is "don't do
835    * that then"
836    */
837   if (print_addr_pipe != NULL && _dbus_pipe_is_valid (print_addr_pipe))
838     {
839       DBusString addr;
840       const char *a = bus_context_get_address (context);
841       int bytes;
842
843       _dbus_assert (a != NULL);
844       if (!_dbus_string_init (&addr))
845         {
846           BUS_SET_OOM (error);
847           goto failed;
848         }
849
850       if (!_dbus_string_append (&addr, a) ||
851           !_dbus_string_append (&addr, "\n"))
852         {
853           _dbus_string_free (&addr);
854           BUS_SET_OOM (error);
855           goto failed;
856         }
857
858       bytes = _dbus_string_get_length (&addr);
859       if (_dbus_pipe_write (print_addr_pipe, &addr, 0, bytes, error) != bytes)
860         {
861           /* pipe write returns an error on failure but not short write */
862           if (error != NULL && !dbus_error_is_set (error))
863             {
864               dbus_set_error (error, DBUS_ERROR_FAILED,
865                               "Printing message bus address: did not write all bytes\n");
866             }
867           _dbus_string_free (&addr);
868           goto failed;
869         }
870
871       if (!_dbus_pipe_is_stdout_or_stderr (print_addr_pipe))
872         _dbus_pipe_close (print_addr_pipe, NULL);
873
874       _dbus_string_free (&addr);
875     }
876
877   context->connections = bus_connections_new (context);
878   if (context->connections == NULL)
879     {
880       BUS_SET_OOM (error);
881       goto failed;
882     }
883
884   context->matchmaker = bus_matchmaker_new ();
885   if (context->matchmaker == NULL)
886     {
887       BUS_SET_OOM (error);
888       goto failed;
889     }
890
891   /* check user before we fork */
892   if (context->user != NULL)
893     {
894       if (!_dbus_verify_daemon_user (context->user))
895         {
896           dbus_set_error (error, DBUS_ERROR_FAILED,
897                           "Could not get UID and GID for username \"%s\"",
898                           context->user);
899           goto failed;
900         }
901     }
902
903   /* Now become a daemon if appropriate and write out pid file in any case */
904   {
905     DBusString u;
906
907     if (context->pidfile)
908       _dbus_string_init_const (&u, context->pidfile);
909
910     if (((flags & BUS_CONTEXT_FLAG_FORK_NEVER) == 0 && context->fork) ||
911         (flags & BUS_CONTEXT_FLAG_FORK_ALWAYS))
912       {
913         _dbus_verbose ("Forking and becoming daemon\n");
914
915         if (!_dbus_become_daemon (context->pidfile ? &u : NULL,
916                                   print_pid_pipe,
917                                   error,
918                                   context->keep_umask))
919           {
920             _DBUS_ASSERT_ERROR_IS_SET (error);
921             goto failed;
922           }
923       }
924     else
925       {
926         _dbus_verbose ("Fork not requested\n");
927
928         /* Need to write PID file and to PID pipe for ourselves,
929          * not for the child process. This is a no-op if the pidfile
930          * is NULL and print_pid_pipe is NULL.
931          */
932         if (!_dbus_write_pid_to_file_and_pipe (context->pidfile ? &u : NULL,
933                                                print_pid_pipe,
934                                                _dbus_getpid (),
935                                                error))
936           {
937             _DBUS_ASSERT_ERROR_IS_SET (error);
938             goto failed;
939           }
940       }
941   }
942
943   if (print_pid_pipe && _dbus_pipe_is_valid (print_pid_pipe) &&
944       !_dbus_pipe_is_stdout_or_stderr (print_pid_pipe))
945     _dbus_pipe_close (print_pid_pipe, NULL);
946
947   if (!bus_selinux_full_init ())
948     {
949       bus_context_log (context, DBUS_SYSTEM_LOG_FATAL, "SELinux enabled but AVC initialization failed; check system log\n");
950     }
951
952   if (!process_config_postinit (context, parser, error))
953     {
954       _DBUS_ASSERT_ERROR_IS_SET (error);
955       goto failed;
956     }
957
958   if (parser != NULL)
959     {
960       bus_config_parser_unref (parser);
961       parser = NULL;
962     }
963
964   /* Here we change our credentials if required,
965    * as soon as we've set up our sockets and pidfile
966    */
967   if (context->user != NULL)
968     {
969       if (!_dbus_change_to_daemon_user (context->user, error))
970         {
971           _DBUS_ASSERT_ERROR_IS_SET (error);
972           goto failed;
973         }
974
975 #ifdef HAVE_SELINUX
976       /* FIXME - why not just put this in full_init() below? */
977       bus_selinux_audit_init ();
978 #endif
979     }
980
981   dbus_server_free_data_slot (&server_data_slot);
982
983 #ifdef ENABLE_KDBUS_TRANSPORT
984   if(context->myKdbusConnection)
985   {
986           DBusString unique_name;
987
988           if(!bus_connections_setup_connection(context->connections, context->myKdbusConnection))
989           {
990           _dbus_verbose ("Bus connections setup connection failed for myKdbusConnection!\n");
991           dbus_connection_close (context->myKdbusConnection);
992           dbus_connection_unref (context->myKdbusConnection);
993           goto failed;
994           }
995           dbus_connection_set_route_peer_messages (context->myKdbusConnection, FALSE);
996           _dbus_string_init_const (&unique_name, ":1.1"); //dbus_bus_get_unique_name(context->myConnection)); this is without :1.
997           if(!bus_connection_complete (context->myKdbusConnection, &unique_name, error))
998           {
999                   _dbus_verbose ("Bus connection complete failed for myKdbusConnection!\n");
1000                   goto failed;
1001           }
1002
1003           if(!register_daemon_name(context->myKdbusConnection))
1004           {
1005               _dbus_verbose ("Registering org.freedesktop.DBus name for daemon failed!\n");
1006               goto failed;
1007           }
1008           if(!register_kdbus_starters(context->myKdbusConnection))
1009           {
1010           _dbus_verbose ("Registering kdbus starters for dbus activatable names failed!\n");
1011           goto failed;
1012           }
1013   }
1014 #endif
1015
1016   return context;
1017
1018  failed:
1019   if (parser != NULL)
1020     bus_config_parser_unref (parser);
1021   if (context != NULL)
1022     bus_context_unref (context);
1023
1024   if (server_data_slot >= 0)
1025     dbus_server_free_data_slot (&server_data_slot);
1026
1027   return NULL;
1028 }
1029
1030 dbus_bool_t
1031 bus_context_get_id (BusContext       *context,
1032                     DBusString       *uuid)
1033 {
1034   return _dbus_uuid_encode (&context->uuid, uuid);
1035 }
1036
1037 dbus_bool_t
1038 bus_context_reload_config (BusContext *context,
1039                            DBusError  *error)
1040 {
1041   BusConfigParser *parser;
1042   DBusString config_file;
1043   dbus_bool_t ret;
1044
1045   /* Flush the user database cache */
1046   _dbus_flush_caches ();
1047
1048   ret = FALSE;
1049   _dbus_string_init_const (&config_file, context->config_file);
1050   parser = bus_config_load (&config_file, TRUE, NULL, error);
1051   if (parser == NULL)
1052     {
1053       _DBUS_ASSERT_ERROR_IS_SET (error);
1054       goto failed;
1055     }
1056
1057   if (!process_config_every_time (context, parser, TRUE, error))
1058     {
1059       _DBUS_ASSERT_ERROR_IS_SET (error);
1060       goto failed;
1061     }
1062   if (!process_config_postinit (context, parser, error))
1063     {
1064       _DBUS_ASSERT_ERROR_IS_SET (error);
1065       goto failed;
1066     }
1067
1068 #ifdef ENABLE_KDBUS_TRANSPORT
1069   if(context->myKdbusConnection)
1070   {
1071       if(!update_kdbus_starters(context->myKdbusConnection))
1072       {
1073           _dbus_verbose ("Update kdbus starters for dbus activatable names failed.\n");
1074           _DBUS_ASSERT_ERROR_IS_SET (error);
1075           goto failed;
1076       }
1077   }
1078 #endif
1079
1080   ret = TRUE;
1081
1082   bus_context_log (context, DBUS_SYSTEM_LOG_INFO, "Reloaded configuration");
1083  failed:
1084   if (!ret)
1085     bus_context_log (context, DBUS_SYSTEM_LOG_INFO, "Unable to reload configuration: %s", error->message);
1086   if (parser != NULL)
1087     bus_config_parser_unref (parser);
1088   return ret;
1089 }
1090
1091 static void
1092 shutdown_server (BusContext *context,
1093                  DBusServer *server)
1094 {
1095   if (server == NULL ||
1096       !dbus_server_get_is_connected (server))
1097     return;
1098
1099   if (!dbus_server_set_watch_functions (server,
1100                                         NULL, NULL, NULL,
1101                                         context,
1102                                         NULL))
1103     _dbus_assert_not_reached ("setting watch functions to NULL failed");
1104
1105   if (!dbus_server_set_timeout_functions (server,
1106                                           NULL, NULL, NULL,
1107                                           context,
1108                                           NULL))
1109     _dbus_assert_not_reached ("setting timeout functions to NULL failed");
1110
1111   dbus_server_disconnect (server);
1112 }
1113
1114 void
1115 bus_context_shutdown (BusContext  *context)
1116 {
1117   DBusList *link;
1118
1119   link = _dbus_list_get_first_link (&context->servers);
1120   while (link != NULL)
1121     {
1122       shutdown_server (context, link->data);
1123
1124       link = _dbus_list_get_next_link (&context->servers, link);
1125     }
1126 }
1127
1128 BusContext *
1129 bus_context_ref (BusContext *context)
1130 {
1131   _dbus_assert (context->refcount > 0);
1132   context->refcount += 1;
1133
1134   return context;
1135 }
1136
1137 void
1138 bus_context_unref (BusContext *context)
1139 {
1140   _dbus_assert (context->refcount > 0);
1141   context->refcount -= 1;
1142
1143   if (context->refcount == 0)
1144     {
1145       DBusList *link;
1146
1147       _dbus_verbose ("Finalizing bus context %p\n", context);
1148
1149       bus_context_shutdown (context);
1150
1151       if (context->connections)
1152         {
1153           bus_connections_unref (context->connections);
1154           context->connections = NULL;
1155         }
1156
1157       if (context->registry)
1158         {
1159           bus_registry_unref (context->registry);
1160           context->registry = NULL;
1161         }
1162
1163       if (context->activation)
1164         {
1165           bus_activation_unref (context->activation);
1166           context->activation = NULL;
1167         }
1168
1169       link = _dbus_list_get_first_link (&context->servers);
1170       while (link != NULL)
1171         {
1172           dbus_server_unref (link->data);
1173
1174           link = _dbus_list_get_next_link (&context->servers, link);
1175         }
1176       _dbus_list_clear (&context->servers);
1177
1178       if (context->policy)
1179         {
1180           bus_policy_unref (context->policy);
1181           context->policy = NULL;
1182         }
1183
1184       if (context->loop)
1185         {
1186           _dbus_loop_unref (context->loop);
1187           context->loop = NULL;
1188         }
1189
1190       if (context->matchmaker)
1191         {
1192           bus_matchmaker_unref (context->matchmaker);
1193           context->matchmaker = NULL;
1194         }
1195
1196       dbus_free (context->config_file);
1197       dbus_free (context->log_prefix);
1198       dbus_free (context->type);
1199       dbus_free (context->address);
1200       dbus_free (context->user);
1201       dbus_free (context->servicehelper);
1202
1203       if (context->pidfile)
1204         {
1205           DBusString u;
1206           _dbus_string_init_const (&u, context->pidfile);
1207
1208           /* Deliberately ignore errors here, since there's not much
1209            * we can do about it, and we're exiting anyways.
1210            */
1211           _dbus_delete_file (&u, NULL);
1212
1213           dbus_free (context->pidfile);
1214         }
1215       dbus_free (context);
1216
1217       dbus_server_free_data_slot (&server_data_slot);
1218     }
1219 }
1220
1221 /* type may be NULL */
1222 const char*
1223 bus_context_get_type (BusContext *context)
1224 {
1225   return context->type;
1226 }
1227
1228 const char*
1229 bus_context_get_address (BusContext *context)
1230 {
1231   return context->address;
1232 }
1233
1234 const char*
1235 bus_context_get_servicehelper (BusContext *context)
1236 {
1237   return context->servicehelper;
1238 }
1239
1240 dbus_bool_t
1241 bus_context_get_systemd_activation (BusContext *context)
1242 {
1243   return context->systemd_activation;
1244 }
1245
1246 BusRegistry*
1247 bus_context_get_registry (BusContext  *context)
1248 {
1249   return context->registry;
1250 }
1251
1252 BusConnections*
1253 bus_context_get_connections (BusContext  *context)
1254 {
1255   return context->connections;
1256 }
1257
1258 BusActivation*
1259 bus_context_get_activation (BusContext  *context)
1260 {
1261   return context->activation;
1262 }
1263
1264 BusMatchmaker*
1265 bus_context_get_matchmaker (BusContext  *context)
1266 {
1267   return context->matchmaker;
1268 }
1269
1270 DBusLoop*
1271 bus_context_get_loop (BusContext *context)
1272 {
1273   return context->loop;
1274 }
1275
1276 dbus_bool_t
1277 bus_context_allow_unix_user (BusContext   *context,
1278                              unsigned long uid)
1279 {
1280   return bus_policy_allow_unix_user (context->policy,
1281                                      uid);
1282 }
1283
1284 /* For now this is never actually called because the default
1285  * DBusConnection behavior of 'same user that owns the bus can connect'
1286  * is all it would do.
1287  */
1288 dbus_bool_t
1289 bus_context_allow_windows_user (BusContext       *context,
1290                                 const char       *windows_sid)
1291 {
1292   return bus_policy_allow_windows_user (context->policy,
1293                                         windows_sid);
1294 }
1295
1296 BusPolicy *
1297 bus_context_get_policy (BusContext *context)
1298 {
1299   return context->policy;
1300 }
1301
1302 BusClientPolicy*
1303 bus_context_create_client_policy (BusContext      *context,
1304                                   DBusConnection  *connection,
1305                                   DBusError       *error)
1306 {
1307   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1308   return bus_policy_create_client_policy (context->policy, connection,
1309                                           error);
1310 }
1311
1312 int
1313 bus_context_get_activation_timeout (BusContext *context)
1314 {
1315
1316   return context->limits.activation_timeout;
1317 }
1318
1319 int
1320 bus_context_get_auth_timeout (BusContext *context)
1321 {
1322   return context->limits.auth_timeout;
1323 }
1324
1325 int
1326 bus_context_get_max_completed_connections (BusContext *context)
1327 {
1328   return context->limits.max_completed_connections;
1329 }
1330
1331 int
1332 bus_context_get_max_incomplete_connections (BusContext *context)
1333 {
1334   return context->limits.max_incomplete_connections;
1335 }
1336
1337 int
1338 bus_context_get_max_connections_per_user (BusContext *context)
1339 {
1340   return context->limits.max_connections_per_user;
1341 }
1342
1343 int
1344 bus_context_get_max_pending_activations (BusContext *context)
1345 {
1346   return context->limits.max_pending_activations;
1347 }
1348
1349 int
1350 bus_context_get_max_services_per_connection (BusContext *context)
1351 {
1352   return context->limits.max_services_per_connection;
1353 }
1354
1355 int
1356 bus_context_get_max_match_rules_per_connection (BusContext *context)
1357 {
1358   return context->limits.max_match_rules_per_connection;
1359 }
1360
1361 int
1362 bus_context_get_max_replies_per_connection (BusContext *context)
1363 {
1364   return context->limits.max_replies_per_connection;
1365 }
1366
1367 int
1368 bus_context_get_reply_timeout (BusContext *context)
1369 {
1370   return context->limits.reply_timeout;
1371 }
1372
1373 #ifdef ENABLE_KDBUS_TRANSPORT
1374 dbus_bool_t bus_context_is_kdbus(BusContext* context)
1375 {
1376         return context->myKdbusConnection != NULL;
1377 }
1378 #endif
1379
1380 void
1381 bus_context_log (BusContext *context, DBusSystemLogSeverity severity, const char *msg, ...) _DBUS_GNUC_PRINTF (3, 4);
1382
1383 void
1384 bus_context_log (BusContext *context, DBusSystemLogSeverity severity, const char *msg, ...)
1385 {
1386   va_list args;
1387
1388   if (!context->syslog)
1389     {
1390       /* we're not syslogging; just output to stderr */
1391       va_start (args, msg);
1392       vfprintf (stderr, msg, args);
1393       fprintf (stderr, "\n");
1394       va_end (args);
1395       return;
1396     }
1397
1398   va_start (args, msg);
1399
1400   if (context->log_prefix)
1401     {
1402       DBusString full_msg;
1403
1404       if (!_dbus_string_init (&full_msg))
1405         goto out;
1406       if (!_dbus_string_append (&full_msg, context->log_prefix))
1407         goto oom_out;
1408       if (!_dbus_string_append_printf_valist (&full_msg, msg, args))
1409         goto oom_out;
1410
1411       _dbus_system_log (severity, "%s", _dbus_string_get_const_data (&full_msg));
1412     oom_out:
1413       _dbus_string_free (&full_msg);
1414     }
1415   else
1416     _dbus_system_logv (severity, msg, args);
1417
1418 out:
1419   va_end (args);
1420 }
1421
1422 static inline const char *
1423 nonnull (const char *maybe_null,
1424          const char *if_null)
1425 {
1426   return (maybe_null ? maybe_null : if_null);
1427 }
1428
1429 /*
1430  * Log something about a message, usually that it was rejected.
1431  */
1432 static void
1433 complain_about_message (BusContext     *context,
1434                         const char     *error_name,
1435                         const char     *complaint,
1436                         int             matched_rules,
1437                         DBusMessage    *message,
1438                         DBusConnection *sender,
1439                         DBusConnection *proposed_recipient,
1440                         dbus_bool_t     requested_reply,
1441                         dbus_bool_t     log,
1442                         DBusError      *error)
1443 {
1444   DBusError stack_error = DBUS_ERROR_INIT;
1445   const char *sender_name;
1446   const char *sender_loginfo;
1447   const char *proposed_recipient_loginfo;
1448
1449   if (error == NULL && !log)
1450     return;
1451
1452   if (sender != NULL)
1453     {
1454       sender_name = bus_connection_get_name (sender);
1455       sender_loginfo = bus_connection_get_loginfo (sender);
1456     }
1457   else
1458     {
1459       sender_name = "(unset)";
1460       sender_loginfo = "(bus)";
1461     }
1462
1463   if (proposed_recipient != NULL)
1464     proposed_recipient_loginfo = bus_connection_get_loginfo (proposed_recipient);
1465   else
1466     proposed_recipient_loginfo = "bus";
1467
1468   dbus_set_error (&stack_error, error_name,
1469       "%s, %d matched rules; type=\"%s\", sender=\"%s\" (%s) "
1470       "interface=\"%s\" member=\"%s\" error name=\"%s\" "
1471       "requested_reply=\"%d\" destination=\"%s\" (%s)",
1472       complaint,
1473       matched_rules,
1474       dbus_message_type_to_string (dbus_message_get_type (message)),
1475       sender_name,
1476       sender_loginfo,
1477       nonnull (dbus_message_get_interface (message), "(unset)"),
1478       nonnull (dbus_message_get_member (message), "(unset)"),
1479       nonnull (dbus_message_get_error_name (message), "(unset)"),
1480       requested_reply,
1481       nonnull (dbus_message_get_destination (message), DBUS_SERVICE_DBUS),
1482       proposed_recipient_loginfo);
1483
1484   /* If we hit OOM while setting the error, this will syslog "out of memory"
1485    * which is itself an indication that something is seriously wrong */
1486   if (log)
1487     bus_context_log (context, DBUS_SYSTEM_LOG_SECURITY, "%s",
1488         stack_error.message);
1489
1490   dbus_move_error (&stack_error, error);
1491 }
1492
1493 /*
1494  * addressed_recipient is the recipient specified in the message.
1495  *
1496  * proposed_recipient is the recipient we're considering sending
1497  * to right this second, and may be an eavesdropper.
1498  *
1499  * sender is the sender of the message.
1500  *
1501  * NULL for proposed_recipient or sender definitely means the bus driver.
1502  *
1503  * NULL for addressed_recipient may mean the bus driver, or may mean
1504  * no destination was specified in the message (e.g. a signal).
1505  */
1506 dbus_bool_t
1507 bus_context_check_security_policy (BusContext     *context,
1508                                    BusTransaction *transaction,
1509                                    DBusConnection *sender,
1510                                    DBusConnection *addressed_recipient,
1511                                    DBusConnection *proposed_recipient,
1512                                    DBusMessage    *message,
1513                                    DBusError      *error)
1514 {
1515   const char *dest;
1516   BusClientPolicy *sender_policy;
1517   BusClientPolicy *recipient_policy;
1518   dbus_int32_t toggles;
1519   dbus_bool_t log;
1520   int type;
1521   dbus_bool_t requested_reply;
1522
1523   type = dbus_message_get_type (message);
1524   dest = dbus_message_get_destination (message);
1525
1526   /* dispatch.c was supposed to ensure these invariants */
1527   _dbus_assert (dest != NULL ||
1528                 type == DBUS_MESSAGE_TYPE_SIGNAL ||
1529                 (sender == NULL && !bus_connection_is_active (proposed_recipient)));
1530   _dbus_assert (type == DBUS_MESSAGE_TYPE_SIGNAL ||
1531                 addressed_recipient != NULL ||
1532                 strcmp (dest, DBUS_SERVICE_DBUS) == 0);
1533
1534   switch (type)
1535     {
1536     case DBUS_MESSAGE_TYPE_METHOD_CALL:
1537     case DBUS_MESSAGE_TYPE_SIGNAL:
1538     case DBUS_MESSAGE_TYPE_METHOD_RETURN:
1539     case DBUS_MESSAGE_TYPE_ERROR:
1540       break;
1541
1542     default:
1543       _dbus_verbose ("security check disallowing message of unknown type %d\n",
1544                      type);
1545
1546       dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
1547                       "Message bus will not accept messages of unknown type\n");
1548
1549       return FALSE;
1550     }
1551
1552   requested_reply = FALSE;
1553
1554   if (sender != NULL)
1555     {
1556       /* First verify the SELinux access controls.  If allowed then
1557        * go on with the standard checks.
1558        */
1559       if (!bus_selinux_allows_send (sender, proposed_recipient,
1560                                     dbus_message_type_to_string (dbus_message_get_type (message)),
1561                                     dbus_message_get_interface (message),
1562                                     dbus_message_get_member (message),
1563                                     dbus_message_get_error_name (message),
1564                                     dest ? dest : DBUS_SERVICE_DBUS, error))
1565         {
1566           if (error != NULL && !dbus_error_is_set (error))
1567             {
1568               /* don't syslog this, just set the error: avc_has_perm should
1569                * have already written to either the audit log or syslog */
1570               complain_about_message (context, DBUS_ERROR_ACCESS_DENIED,
1571                   "An SELinux policy prevents this sender from sending this "
1572                   "message to this recipient",
1573                   0, message, sender, proposed_recipient, FALSE, FALSE, error);
1574               _dbus_verbose ("SELinux security check denying send to service\n");
1575             }
1576
1577           return FALSE;
1578         }
1579
1580       if (bus_connection_is_active (sender))
1581         {
1582           sender_policy = bus_connection_get_policy (sender);
1583           _dbus_assert (sender_policy != NULL);
1584
1585           /* Fill in requested_reply variable with TRUE if this is a
1586            * reply and the reply was pending.
1587            */
1588           if (dbus_message_get_reply_serial (message) != 0)
1589             {
1590               if (proposed_recipient != NULL /* not to the bus driver */ &&
1591                   addressed_recipient == proposed_recipient /* not eavesdropping */)
1592                 {
1593                   DBusError error2;
1594
1595                   dbus_error_init (&error2);
1596                   requested_reply = bus_connections_check_reply (bus_connection_get_connections (sender),
1597                                                                  transaction,
1598                                                                  sender, addressed_recipient, message,
1599                                                                  &error2);
1600                   if (dbus_error_is_set (&error2))
1601                     {
1602                       dbus_move_error (&error2, error);
1603                       return FALSE;
1604                     }
1605                 }
1606             }
1607         }
1608       else
1609         {
1610           /* Policy for inactive connections is that they can only send
1611            * the hello message to the bus driver
1612            */
1613           if (proposed_recipient == NULL &&
1614               dbus_message_is_method_call (message,
1615                                            DBUS_INTERFACE_DBUS,
1616                                            "Hello"))
1617             {
1618               _dbus_verbose ("security check allowing %s message\n",
1619                              "Hello");
1620               return TRUE;
1621             }
1622           else
1623             {
1624               _dbus_verbose ("security check disallowing non-%s message\n",
1625                              "Hello");
1626
1627               dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED,
1628                               "Client tried to send a message other than %s without being registered",
1629                               "Hello");
1630
1631               return FALSE;
1632             }
1633         }
1634     }
1635   else
1636     {
1637       sender_policy = NULL;
1638
1639       /* If the sender is the bus driver, we assume any reply was a
1640        * requested reply as bus driver won't send bogus ones
1641        */
1642       if (addressed_recipient == proposed_recipient /* not eavesdropping */ &&
1643           dbus_message_get_reply_serial (message) != 0)
1644         requested_reply = TRUE;
1645     }
1646
1647   _dbus_assert ((sender != NULL && sender_policy != NULL) ||
1648                 (sender == NULL && sender_policy == NULL));
1649
1650   if (proposed_recipient != NULL)
1651     {
1652       /* only the bus driver can send to an inactive recipient (as it
1653        * owns no services, so other apps can't address it). Inactive
1654        * recipients can receive any message.
1655        */
1656       if (bus_connection_is_active (proposed_recipient))
1657         {
1658           recipient_policy = bus_connection_get_policy (proposed_recipient);
1659           _dbus_assert (recipient_policy != NULL);
1660         }
1661       else if (sender == NULL)
1662         {
1663           _dbus_verbose ("security check using NULL recipient policy for message from bus\n");
1664           recipient_policy = NULL;
1665         }
1666       else
1667         {
1668           _dbus_assert_not_reached ("a message was somehow sent to an inactive recipient from a source other than the message bus\n");
1669           recipient_policy = NULL;
1670         }
1671     }
1672   else
1673     recipient_policy = NULL;
1674
1675   _dbus_assert ((proposed_recipient != NULL && recipient_policy != NULL) ||
1676                 (proposed_recipient != NULL && sender == NULL && recipient_policy == NULL) ||
1677                 (proposed_recipient == NULL && recipient_policy == NULL));
1678
1679   log = FALSE;
1680   if (sender_policy &&
1681       !bus_client_policy_check_can_send (sender_policy,
1682                                          context->registry,
1683                                          requested_reply,
1684                                          proposed_recipient,
1685                                          message, &toggles, &log))
1686     {
1687       complain_about_message (context, DBUS_ERROR_ACCESS_DENIED,
1688           "Rejected send message", toggles,
1689           message, sender, proposed_recipient, requested_reply,
1690           (addressed_recipient == proposed_recipient), error);
1691       _dbus_verbose ("security policy disallowing message due to sender policy\n");
1692       return FALSE;
1693     }
1694
1695   if (log)
1696     {
1697       /* We want to drop this message, and are only not doing so for backwards
1698        * compatibility. */
1699       complain_about_message (context, DBUS_ERROR_ACCESS_DENIED,
1700           "Would reject message", toggles,
1701           message, sender, proposed_recipient, requested_reply,
1702           TRUE, NULL);
1703     }
1704
1705   if (recipient_policy &&
1706       !bus_client_policy_check_can_receive (recipient_policy,
1707                                             context->registry,
1708                                             requested_reply,
1709                                             sender,
1710                                             addressed_recipient, proposed_recipient,
1711                                             message, &toggles))
1712     {
1713       complain_about_message (context, DBUS_ERROR_ACCESS_DENIED,
1714           "Rejected receive message", toggles,
1715           message, sender, proposed_recipient, requested_reply,
1716           (addressed_recipient == proposed_recipient), NULL);
1717       _dbus_verbose ("security policy disallowing message due to recipient policy\n");
1718       return FALSE;
1719     }
1720
1721   /* See if limits on size have been exceeded */
1722   if (proposed_recipient &&
1723       ((dbus_connection_get_outgoing_size (proposed_recipient) > context->limits.max_outgoing_bytes) ||
1724        (dbus_connection_get_outgoing_unix_fds (proposed_recipient) > context->limits.max_outgoing_unix_fds)))
1725     {
1726       complain_about_message (context, DBUS_ERROR_LIMITS_EXCEEDED,
1727           "Rejected: destination has a full message queue",
1728           0, message, sender, proposed_recipient, requested_reply, TRUE,
1729           error);
1730       _dbus_verbose ("security policy disallowing message due to full message queue\n");
1731       return FALSE;
1732     }
1733
1734   /* Record that we will allow a reply here in the future (don't
1735    * bother if the recipient is the bus or this is an eavesdropping
1736    * connection). Only the addressed recipient may reply.
1737    */
1738   if (type == DBUS_MESSAGE_TYPE_METHOD_CALL &&
1739       sender &&
1740       addressed_recipient &&
1741       addressed_recipient == proposed_recipient && /* not eavesdropping */
1742       !bus_connections_expect_reply (bus_connection_get_connections (sender),
1743                                      transaction,
1744                                      sender, addressed_recipient,
1745                                      message, error))
1746     {
1747       _dbus_verbose ("Failed to record reply expectation or problem with the message expecting a reply\n");
1748       return FALSE;
1749     }
1750
1751   _dbus_verbose ("security policy allowing message\n");
1752   return TRUE;
1753 }