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