bus/bus.c

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