bus/config-parser.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* config-parser.c  XML-library-agnostic configuration file parser
   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 "config-parser-common.h"
  26 #include "config-parser.h"
  27 #include "test.h"
  28 #include "utils.h"
  29 #include "policy.h"
  30 #include "selinux.h"
  31 #include <dbus/dbus-list.h>
  32 #include <dbus/dbus-internals.h>
  33 #include <string.h>
  34
  35 typedef enum
  36 {
  37   /* we ignore policies for unknown groups/users */
  38   POLICY_IGNORED,
  39
  40   /* non-ignored */
  41   POLICY_DEFAULT,
  42   POLICY_MANDATORY,
  43   POLICY_USER,
  44   POLICY_GROUP,
  45   POLICY_CONSOLE
  46 } PolicyType;
  47
  48 typedef struct
  49 {
  50   ElementType type;
  51
  52   unsigned int had_content : 1;
  53
  54   union
  55   {
  56     struct
  57     {
  58       unsigned int ignore_missing : 1;
  59       unsigned int if_selinux_enabled : 1;
  60       unsigned int selinux_root_relative : 1;
  61     } include;
  62
  63     struct
  64     {
  65       PolicyType type;
  66       unsigned long gid_uid_or_at_console;
  67     } policy;
  68
  69     struct
  70     {
  71       char *name;
  72       long value;
  73     } limit;
  74
  75   } d;
  76
  77 } Element;
  78
  79 /**
  80  * Parser for bus configuration file.
  81  */
  82 struct BusConfigParser
  83 {
  84   int refcount;        /**< Reference count */
  85
  86   DBusString basedir;  /**< Directory we resolve paths relative to */
  87
  88   DBusList *stack;     /**< stack of Element */
  89
  90   char *user;          /**< user to run as */
  91
  92   char *servicehelper; /**< location of the setuid helper */
  93
  94   char *bus_type;          /**< Message bus type */
  95
  96   DBusList *listen_on; /**< List of addresses to listen to */
  97
  98   DBusList *mechanisms; /**< Auth mechanisms */
  99
 100   DBusList *service_dirs; /**< Directories to look for session services in */
 101
 102   DBusList *conf_dirs;   /**< Directories to look for policy configuration in */
 103
 104   BusPolicy *policy;     /**< Security policy */
 105
 106   BusLimits limits;      /**< Limits */
 107
 108   char *pidfile;         /**< PID file */
 109
 110   DBusList *included_files;  /**< Included files stack */
 111
 112   DBusHashTable *service_context_table; /**< Map service names to SELinux contexts */
 113
 114   unsigned int fork : 1; /**< TRUE to fork into daemon mode */
 115
 116   unsigned int syslog : 1; /**< TRUE to enable syslog */
 117   unsigned int keep_umask : 1; /**< TRUE to keep original umask when forking */
 118
 119   unsigned int is_toplevel : 1; /**< FALSE if we are a sub-config-file inside another one */
 120
 121   unsigned int allow_anonymous : 1; /**< TRUE to allow anonymous connections */
 122 };
 123
 124 static Element*
 125 push_element (BusConfigParser *parser,
 126               ElementType      type)
 127 {
 128   Element *e;
 129
 130   _dbus_assert (type != ELEMENT_NONE);
 131
 132   e = dbus_new0 (Element, 1);
 133   if (e == NULL)
 134     return NULL;
 135
 136   if (!_dbus_list_append (&parser->stack, e))
 137     {
 138       dbus_free (e);
 139       return NULL;
 140     }
 141
 142   e->type = type;
 143
 144   return e;
 145 }
 146
 147 static void
 148 element_free (Element *e)
 149 {
 150   if (e->type == ELEMENT_LIMIT)
 151     dbus_free (e->d.limit.name);
 152
 153   dbus_free (e);
 154 }
 155
 156 static void
 157 pop_element (BusConfigParser *parser)
 158 {
 159   Element *e;
 160
 161   e = _dbus_list_pop_last (&parser->stack);
 162
 163   element_free (e);
 164 }
 165
 166 static Element*
 167 peek_element (BusConfigParser *parser)
 168 {
 169   Element *e;
 170
 171   e = _dbus_list_get_last (&parser->stack);
 172
 173   return e;
 174 }
 175
 176 static ElementType
 177 top_element_type (BusConfigParser *parser)
 178 {
 179   Element *e;
 180
 181   e = _dbus_list_get_last (&parser->stack);
 182
 183   if (e)
 184     return e->type;
 185   else
 186     return ELEMENT_NONE;
 187 }
 188
 189 static dbus_bool_t
 190 merge_service_context_hash (DBusHashTable *dest,
 191                             DBusHashTable *from)
 192 {
 193   DBusHashIter iter;
 194   char *service_copy;
 195   char *context_copy;
 196
 197   service_copy = NULL;
 198   context_copy = NULL;
 199
 200   _dbus_hash_iter_init (from, &iter);
 201   while (_dbus_hash_iter_next (&iter))
 202     {
 203       const char *service = _dbus_hash_iter_get_string_key (&iter);
 204       const char *context = _dbus_hash_iter_get_value (&iter);
 205
 206       service_copy = _dbus_strdup (service);
 207       if (service_copy == NULL)
 208         goto fail;
 209       context_copy = _dbus_strdup (context);
 210       if (context_copy == NULL)
 211         goto fail;
 212
 213       if (!_dbus_hash_table_insert_string (dest, service_copy, context_copy))
 214         goto fail;
 215
 216       service_copy = NULL;
 217       context_copy = NULL;
 218     }
 219
 220   return TRUE;
 221
 222  fail:
 223   if (service_copy)
 224     dbus_free (service_copy);
 225
 226   if (context_copy)
 227     dbus_free (context_copy);
 228
 229   return FALSE;
 230 }
 231
 232 static dbus_bool_t
 233 service_dirs_find_dir (DBusList **service_dirs,
 234                        const char *dir)
 235 {
 236   DBusList *link;
 237
 238   _dbus_assert (dir != NULL);
 239
 240   for (link = *service_dirs; link; link = _dbus_list_get_next_link(service_dirs, link))
 241     {
 242       const char *link_dir;
 243
 244       link_dir = (const char *)link->data;
 245       if (strcmp (dir, link_dir) == 0)
 246         return TRUE;
 247     }
 248
 249   return FALSE;
 250 }
 251
 252 static dbus_bool_t
 253 service_dirs_append_unique_or_free (DBusList **service_dirs,
 254                                     char *dir)
 255 {
 256   if (!service_dirs_find_dir (service_dirs, dir))
 257     return _dbus_list_append (service_dirs, dir);
 258
 259   dbus_free (dir);
 260   return TRUE;
 261 }
 262
 263 static void
 264 service_dirs_append_link_unique_or_free (DBusList **service_dirs,
 265                                          DBusList *dir_link)
 266 {
 267   if (!service_dirs_find_dir (service_dirs, dir_link->data))
 268     {
 269       _dbus_list_append_link (service_dirs, dir_link);
 270     }
 271   else
 272     {
 273       dbus_free (dir_link->data);
 274       _dbus_list_free_link (dir_link);
 275     }
 276 }
 277
 278 static dbus_bool_t
 279 merge_included (BusConfigParser *parser,
 280                 BusConfigParser *included,
 281                 DBusError       *error)
 282 {
 283   DBusList *link;
 284
 285   if (!bus_policy_merge (parser->policy,
 286                          included->policy))
 287     {
 288       BUS_SET_OOM (error);
 289       return FALSE;
 290     }
 291
 292   if (!merge_service_context_hash (parser->service_context_table,
 293                                    included->service_context_table))
 294     {
 295       BUS_SET_OOM (error);
 296       return FALSE;
 297     }
 298
 299   if (included->user != NULL)
 300     {
 301       dbus_free (parser->user);
 302       parser->user = included->user;
 303       included->user = NULL;
 304     }
 305
 306   if (included->bus_type != NULL)
 307     {
 308       dbus_free (parser->bus_type);
 309       parser->bus_type = included->bus_type;
 310       included->bus_type = NULL;
 311     }
 312
 313   if (included->fork)
 314     parser->fork = TRUE;
 315
 316   if (included->keep_umask)
 317     parser->keep_umask = TRUE;
 318
 319   if (included->pidfile != NULL)
 320     {
 321       dbus_free (parser->pidfile);
 322       parser->pidfile = included->pidfile;
 323       included->pidfile = NULL;
 324     }
 325
 326   while ((link = _dbus_list_pop_first_link (&included->listen_on)))
 327     _dbus_list_append_link (&parser->listen_on, link);
 328
 329   while ((link = _dbus_list_pop_first_link (&included->mechanisms)))
 330     _dbus_list_append_link (&parser->mechanisms, link);
 331
 332   while ((link = _dbus_list_pop_first_link (&included->service_dirs)))
 333     service_dirs_append_link_unique_or_free (&parser->service_dirs, link);
 334
 335   while ((link = _dbus_list_pop_first_link (&included->conf_dirs)))
 336     _dbus_list_append_link (&parser->conf_dirs, link);
 337
 338   return TRUE;
 339 }
 340
 341 static dbus_bool_t
 342 seen_include (BusConfigParser  *parser,
 343               const DBusString *file)
 344 {
 345   DBusList *iter;
 346
 347   iter = parser->included_files;
 348   while (iter != NULL)
 349     {
 350       if (! strcmp (_dbus_string_get_const_data (file), iter->data))
 351         return TRUE;
 352
 353       iter = _dbus_list_get_next_link (&parser->included_files, iter);
 354     }
 355
 356   return FALSE;
 357 }
 358
 359 BusConfigParser*
 360 bus_config_parser_new (const DBusString      *basedir,
 361                        dbus_bool_t            is_toplevel,
 362                        const BusConfigParser *parent)
 363 {
 364   BusConfigParser *parser;
 365
 366   parser = dbus_new0 (BusConfigParser, 1);
 367   if (parser == NULL)
 368     return NULL;
 369
 370   parser->is_toplevel = !!is_toplevel;
 371
 372   if (!_dbus_string_init (&parser->basedir))
 373     {
 374       dbus_free (parser);
 375       return NULL;
 376     }
 377
 378   if (((parser->policy = bus_policy_new ()) == NULL) ||
 379       !_dbus_string_copy (basedir, 0, &parser->basedir, 0) ||
 380       ((parser->service_context_table = _dbus_hash_table_new (DBUS_HASH_STRING,
 381                                                               dbus_free,
 382                                                               dbus_free)) == NULL))
 383     {
 384       if (parser->policy)
 385         bus_policy_unref (parser->policy);
 386
 387       _dbus_string_free (&parser->basedir);
 388
 389       dbus_free (parser);
 390       return NULL;
 391     }
 392
 393   if (parent != NULL)
 394     {
 395       /* Initialize the parser's limits from the parent. */
 396       parser->limits = parent->limits;
 397
 398       /* Use the parent's list of included_files to avoid
 399          circular inclusions. */
 400       parser->included_files = parent->included_files;
 401     }
 402   else
 403     {
 404
 405       /* Make up some numbers! woot! */
 406       parser->limits.max_incoming_bytes = _DBUS_ONE_MEGABYTE * 127;
 407       parser->limits.max_outgoing_bytes = _DBUS_ONE_MEGABYTE * 127;
 408       parser->limits.max_message_size = _DBUS_ONE_MEGABYTE * 32;
 409
 410       /* We set relatively conservative values here since due to the
 411       way SCM_RIGHTS works we need to preallocate an array for the
 412       maximum number of file descriptors we can receive. Picking a
 413       high value here thus translates directly to more memory
 414       allocation. */
 415       parser->limits.max_incoming_unix_fds = 1024*4;
 416       parser->limits.max_outgoing_unix_fds = 1024*4;
 417       parser->limits.max_message_unix_fds = 1024;
 418
 419       /* Making this long means the user has to wait longer for an error
 420        * message if something screws up, but making it too short means
 421        * they might see a false failure.
 422        */
 423       parser->limits.activation_timeout = 25000; /* 25 seconds */
 424
 425       /* Making this long risks making a DOS attack easier, but too short
 426        * and legitimate auth will fail.  If interactive auth (ask user for
 427        * password) is allowed, then potentially it has to be quite long.
 428        */
 429       parser->limits.auth_timeout = 30000; /* 30 seconds */
 430
 431       parser->limits.max_incomplete_connections = 64;
 432       parser->limits.max_connections_per_user = 256;
 433
 434       /* Note that max_completed_connections / max_connections_per_user
 435        * is the number of users that would have to work together to
 436        * DOS all the other users.
 437        */
 438       parser->limits.max_completed_connections = 2048;
 439
 440       parser->limits.max_pending_activations = 512;
 441       parser->limits.max_services_per_connection = 512;
 442
 443       /* For this one, keep in mind that it isn't only the memory used
 444        * by the match rules, but slowdown from linearly walking a big
 445        * list of them. A client adding more than this is almost
 446        * certainly a bad idea for that reason, and should change to a
 447        * smaller number of wider-net match rules - getting every last
 448        * message to the bus is probably better than having a thousand
 449        * match rules.
 450        */
 451       parser->limits.max_match_rules_per_connection = 512;
 452
 453       parser->limits.reply_timeout = -1; /* never */
 454
 455       /* this is effectively a limit on message queue size for messages
 456        * that require a reply
 457        */
 458       parser->limits.max_replies_per_connection = 1024*8;
 459     }
 460
 461   parser->refcount = 1;
 462
 463   return parser;
 464 }
 465
 466 BusConfigParser *
 467 bus_config_parser_ref (BusConfigParser *parser)
 468 {
 469   _dbus_assert (parser->refcount > 0);
 470
 471   parser->refcount += 1;
 472
 473   return parser;
 474 }
 475
 476 void
 477 bus_config_parser_unref (BusConfigParser *parser)
 478 {
 479   _dbus_assert (parser->refcount > 0);
 480
 481   parser->refcount -= 1;
 482
 483   if (parser->refcount == 0)
 484     {
 485       while (parser->stack != NULL)
 486         pop_element (parser);
 487
 488       dbus_free (parser->user);
 489       dbus_free (parser->servicehelper);
 490       dbus_free (parser->bus_type);
 491       dbus_free (parser->pidfile);
 492
 493       _dbus_list_foreach (&parser->listen_on,
 494                           (DBusForeachFunction) dbus_free,
 495                           NULL);
 496
 497       _dbus_list_clear (&parser->listen_on);
 498
 499       _dbus_list_foreach (&parser->service_dirs,
 500                           (DBusForeachFunction) dbus_free,
 501                           NULL);
 502
 503       _dbus_list_clear (&parser->service_dirs);
 504
 505       _dbus_list_foreach (&parser->conf_dirs,
 506                           (DBusForeachFunction) dbus_free,
 507                           NULL);
 508
 509       _dbus_list_clear (&parser->conf_dirs);
 510
 511       _dbus_list_foreach (&parser->mechanisms,
 512                           (DBusForeachFunction) dbus_free,
 513                           NULL);
 514
 515       _dbus_list_clear (&parser->mechanisms);
 516
 517       _dbus_string_free (&parser->basedir);
 518
 519       if (parser->policy)
 520         bus_policy_unref (parser->policy);
 521
 522       if (parser->service_context_table)
 523         _dbus_hash_table_unref (parser->service_context_table);
 524
 525       dbus_free (parser);
 526     }
 527 }
 528
 529 dbus_bool_t
 530 bus_config_parser_check_doctype (BusConfigParser   *parser,
 531                                  const char        *doctype,
 532                                  DBusError         *error)
 533 {
 534   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 535
 536   if (strcmp (doctype, "busconfig") != 0)
 537     {
 538       dbus_set_error (error,
 539                       DBUS_ERROR_FAILED,
 540                       "Configuration file has the wrong document type %s",
 541                       doctype);
 542       return FALSE;
 543     }
 544   else
 545     return TRUE;
 546 }
 547
 548 typedef struct
 549 {
 550   const char  *name;
 551   const char **retloc;
 552 } LocateAttr;
 553
 554 static dbus_bool_t
 555 locate_attributes (BusConfigParser  *parser,
 556                    const char       *element_name,
 557                    const char      **attribute_names,
 558                    const char      **attribute_values,
 559                    DBusError        *error,
 560                    const char       *first_attribute_name,
 561                    const char      **first_attribute_retloc,
 562                    ...)
 563 {
 564   va_list args;
 565   const char *name;
 566   const char **retloc;
 567   int n_attrs;
 568 #define MAX_ATTRS 24
 569   LocateAttr attrs[MAX_ATTRS];
 570   dbus_bool_t retval;
 571   int i;
 572
 573   _dbus_assert (first_attribute_name != NULL);
 574   _dbus_assert (first_attribute_retloc != NULL);
 575
 576   retval = TRUE;
 577
 578   n_attrs = 1;
 579   attrs[0].name = first_attribute_name;
 580   attrs[0].retloc = first_attribute_retloc;
 581   *first_attribute_retloc = NULL;
 582
 583   va_start (args, first_attribute_retloc);
 584
 585   name = va_arg (args, const char*);
 586   retloc = va_arg (args, const char**);
 587
 588   while (name != NULL)
 589     {
 590       _dbus_assert (retloc != NULL);
 591       _dbus_assert (n_attrs < MAX_ATTRS);
 592
 593       attrs[n_attrs].name = name;
 594       attrs[n_attrs].retloc = retloc;
 595       n_attrs += 1;
 596       *retloc = NULL;
 597
 598       name = va_arg (args, const char*);
 599       retloc = va_arg (args, const char**);
 600     }
 601
 602   va_end (args);
 603
 604   i = 0;
 605   while (attribute_names[i])
 606     {
 607       int j;
 608       dbus_bool_t found;
 609
 610       found = FALSE;
 611       j = 0;
 612       while (j < n_attrs)
 613         {
 614           if (strcmp (attrs[j].name, attribute_names[i]) == 0)
 615             {
 616               retloc = attrs[j].retloc;
 617
 618               if (*retloc != NULL)
 619                 {
 620                   dbus_set_error (error, DBUS_ERROR_FAILED,
 621                                   "Attribute \"%s\" repeated twice on the same <%s> element",
 622                                   attrs[j].name, element_name);
 623                   retval = FALSE;
 624                   goto out;
 625                 }
 626
 627               *retloc = attribute_values[i];
 628               found = TRUE;
 629             }
 630
 631           ++j;
 632         }
 633
 634       if (!found)
 635         {
 636           dbus_set_error (error, DBUS_ERROR_FAILED,
 637                           "Attribute \"%s\" is invalid on <%s> element in this context",
 638                           attribute_names[i], element_name);
 639           retval = FALSE;
 640           goto out;
 641         }
 642
 643       ++i;
 644     }
 645
 646  out:
 647   return retval;
 648 }
 649
 650 static dbus_bool_t
 651 check_no_attributes (BusConfigParser  *parser,
 652                      const char       *element_name,
 653                      const char      **attribute_names,
 654                      const char      **attribute_values,
 655                      DBusError        *error)
 656 {
 657   if (attribute_names[0] != NULL)
 658     {
 659       dbus_set_error (error, DBUS_ERROR_FAILED,
 660                       "Attribute \"%s\" is invalid on <%s> element in this context",
 661                       attribute_names[0], element_name);
 662       return FALSE;
 663     }
 664
 665   return TRUE;
 666 }
 667
 668 static dbus_bool_t
 669 start_busconfig_child (BusConfigParser   *parser,
 670                        const char        *element_name,
 671                        const char       **attribute_names,
 672                        const char       **attribute_values,
 673                        DBusError         *error)
 674 {
 675   ElementType element_type;
 676
 677   element_type = bus_config_parser_element_name_to_type (element_name);
 678
 679   if (element_type == ELEMENT_USER)
 680     {
 681       if (!check_no_attributes (parser, "user", attribute_names, attribute_values, error))
 682         return FALSE;
 683
 684       if (push_element (parser, ELEMENT_USER) == NULL)
 685         {
 686           BUS_SET_OOM (error);
 687           return FALSE;
 688         }
 689
 690       return TRUE;
 691     }
 692   else if (element_type == ELEMENT_TYPE)
 693     {
 694       if (!check_no_attributes (parser, "type", attribute_names, attribute_values, error))
 695         return FALSE;
 696
 697       if (push_element (parser, ELEMENT_TYPE) == NULL)
 698         {
 699           BUS_SET_OOM (error);
 700           return FALSE;
 701         }
 702
 703       return TRUE;
 704     }
 705   else if (element_type == ELEMENT_FORK)
 706     {
 707       if (!check_no_attributes (parser, "fork", attribute_names, attribute_values, error))
 708         return FALSE;
 709
 710       if (push_element (parser, ELEMENT_FORK) == NULL)
 711         {
 712           BUS_SET_OOM (error);
 713           return FALSE;
 714         }
 715
 716       parser->fork = TRUE;
 717
 718       return TRUE;
 719     }
 720   else if (element_type == ELEMENT_SYSLOG)
 721     {
 722       if (!check_no_attributes (parser, "syslog", attribute_names, attribute_values, error))
 723         return FALSE;
 724
 725       if (push_element (parser, ELEMENT_SYSLOG) == NULL)
 726         {
 727           BUS_SET_OOM (error);
 728           return FALSE;
 729         }
 730
 731       parser->syslog = TRUE;
 732
 733       return TRUE;
 734     }
 735   else if (element_type == ELEMENT_KEEP_UMASK)
 736     {
 737       if (!check_no_attributes (parser, "keep_umask", attribute_names, attribute_values, error))
 738         return FALSE;
 739
 740       if (push_element (parser, ELEMENT_KEEP_UMASK) == NULL)
 741         {
 742           BUS_SET_OOM (error);
 743           return FALSE;
 744         }
 745
 746       parser->keep_umask = TRUE;
 747
 748       return TRUE;
 749     }
 750   else if (element_type == ELEMENT_PIDFILE)
 751     {
 752       if (!check_no_attributes (parser, "pidfile", attribute_names, attribute_values, error))
 753         return FALSE;
 754
 755       if (push_element (parser, ELEMENT_PIDFILE) == NULL)
 756         {
 757           BUS_SET_OOM (error);
 758           return FALSE;
 759         }
 760
 761       return TRUE;
 762     }
 763   else if (element_type == ELEMENT_LISTEN)
 764     {
 765       if (!check_no_attributes (parser, "listen", attribute_names, attribute_values, error))
 766         return FALSE;
 767
 768       if (push_element (parser, ELEMENT_LISTEN) == NULL)
 769         {
 770           BUS_SET_OOM (error);
 771           return FALSE;
 772         }
 773
 774       return TRUE;
 775     }
 776   else if (element_type == ELEMENT_AUTH)
 777     {
 778       if (!check_no_attributes (parser, "auth", attribute_names, attribute_values, error))
 779         return FALSE;
 780
 781       if (push_element (parser, ELEMENT_AUTH) == NULL)
 782         {
 783           BUS_SET_OOM (error);
 784           return FALSE;
 785         }
 786
 787       return TRUE;
 788     }
 789   else if (element_type == ELEMENT_SERVICEHELPER)
 790     {
 791       if (!check_no_attributes (parser, "servicehelper", attribute_names, attribute_values, error))
 792         return FALSE;
 793
 794       if (push_element (parser, ELEMENT_SERVICEHELPER) == NULL)
 795         {
 796           BUS_SET_OOM (error);
 797           return FALSE;
 798         }
 799
 800       return TRUE;
 801     }
 802   else if (element_type == ELEMENT_INCLUDEDIR)
 803     {
 804       if (!check_no_attributes (parser, "includedir", attribute_names, attribute_values, error))
 805         return FALSE;
 806
 807       if (push_element (parser, ELEMENT_INCLUDEDIR) == NULL)
 808         {
 809           BUS_SET_OOM (error);
 810           return FALSE;
 811         }
 812
 813       return TRUE;
 814     }
 815   else if (element_type == ELEMENT_STANDARD_SESSION_SERVICEDIRS)
 816     {
 817       DBusList *link;
 818       DBusList *dirs;
 819       dirs = NULL;
 820
 821       if (!check_no_attributes (parser, "standard_session_servicedirs", attribute_names, attribute_values, error))
 822         return FALSE;
 823
 824       if (push_element (parser, ELEMENT_STANDARD_SESSION_SERVICEDIRS) == NULL)
 825         {
 826           BUS_SET_OOM (error);
 827           return FALSE;
 828         }
 829
 830       if (!_dbus_get_standard_session_servicedirs (&dirs))
 831         {
 832           BUS_SET_OOM (error);
 833           return FALSE;
 834         }
 835
 836         while ((link = _dbus_list_pop_first_link (&dirs)))
 837           service_dirs_append_link_unique_or_free (&parser->service_dirs, link);
 838
 839       return TRUE;
 840     }
 841   else if (element_type == ELEMENT_STANDARD_SYSTEM_SERVICEDIRS)
 842     {
 843       DBusList *link;
 844       DBusList *dirs;
 845       dirs = NULL;
 846
 847       if (!check_no_attributes (parser, "standard_system_servicedirs", attribute_names, attribute_values, error))
 848         return FALSE;
 849
 850       if (push_element (parser, ELEMENT_STANDARD_SYSTEM_SERVICEDIRS) == NULL)
 851         {
 852           BUS_SET_OOM (error);
 853           return FALSE;
 854         }
 855
 856       if (!_dbus_get_standard_system_servicedirs (&dirs))
 857         {
 858           BUS_SET_OOM (error);
 859           return FALSE;
 860         }
 861
 862         while ((link = _dbus_list_pop_first_link (&dirs)))
 863           service_dirs_append_link_unique_or_free (&parser->service_dirs, link);
 864
 865       return TRUE;
 866     }
 867   else if (element_type == ELEMENT_ALLOW_ANONYMOUS)
 868     {
 869       if (!check_no_attributes (parser, "allow_anonymous", attribute_names, attribute_values, error))
 870         return FALSE;
 871
 872       if (push_element (parser, ELEMENT_ALLOW_ANONYMOUS) == NULL)
 873         {
 874           BUS_SET_OOM (error);
 875           return FALSE;
 876         }
 877
 878       parser->allow_anonymous = TRUE;
 879       return TRUE;
 880     }
 881   else if (element_type == ELEMENT_SERVICEDIR)
 882     {
 883       if (!check_no_attributes (parser, "servicedir", attribute_names, attribute_values, error))
 884         return FALSE;
 885
 886       if (push_element (parser, ELEMENT_SERVICEDIR) == NULL)
 887         {
 888           BUS_SET_OOM (error);
 889           return FALSE;
 890         }
 891
 892       return TRUE;
 893     }
 894   else if (element_type == ELEMENT_INCLUDE)
 895     {
 896       Element *e;
 897       const char *if_selinux_enabled;
 898       const char *ignore_missing;
 899       const char *selinux_root_relative;
 900
 901       if ((e = push_element (parser, ELEMENT_INCLUDE)) == NULL)
 902         {
 903           BUS_SET_OOM (error);
 904           return FALSE;
 905         }
 906
 907       e->d.include.ignore_missing = FALSE;
 908       e->d.include.if_selinux_enabled = FALSE;
 909       e->d.include.selinux_root_relative = FALSE;
 910
 911       if (!locate_attributes (parser, "include",
 912                               attribute_names,
 913                               attribute_values,
 914                               error,
 915                               "ignore_missing", &ignore_missing,
 916                               "if_selinux_enabled", &if_selinux_enabled,
 917                               "selinux_root_relative", &selinux_root_relative,
 918                               NULL))
 919         return FALSE;
 920
 921       if (ignore_missing != NULL)
 922         {
 923           if (strcmp (ignore_missing, "yes") == 0)
 924             e->d.include.ignore_missing = TRUE;
 925           else if (strcmp (ignore_missing, "no") == 0)
 926             e->d.include.ignore_missing = FALSE;
 927           else
 928             {
 929               dbus_set_error (error, DBUS_ERROR_FAILED,
 930                               "ignore_missing attribute must have value \"yes\" or \"no\"");
 931               return FALSE;
 932             }
 933         }
 934
 935       if (if_selinux_enabled != NULL)
 936         {
 937           if (strcmp (if_selinux_enabled, "yes") == 0)
 938             e->d.include.if_selinux_enabled = TRUE;
 939           else if (strcmp (if_selinux_enabled, "no") == 0)
 940             e->d.include.if_selinux_enabled = FALSE;
 941           else
 942             {
 943               dbus_set_error (error, DBUS_ERROR_FAILED,
 944                               "if_selinux_enabled attribute must have value"
 945                               " \"yes\" or \"no\"");
 946               return FALSE;
 947             }
 948         }
 949
 950       if (selinux_root_relative != NULL)
 951         {
 952           if (strcmp (selinux_root_relative, "yes") == 0)
 953             e->d.include.selinux_root_relative = TRUE;
 954           else if (strcmp (selinux_root_relative, "no") == 0)
 955             e->d.include.selinux_root_relative = FALSE;
 956           else
 957             {
 958               dbus_set_error (error, DBUS_ERROR_FAILED,
 959                               "selinux_root_relative attribute must have value"
 960                               " \"yes\" or \"no\"");
 961               return FALSE;
 962             }
 963         }
 964
 965       return TRUE;
 966     }
 967   else if (element_type == ELEMENT_POLICY)
 968     {
 969       Element *e;
 970       const char *context;
 971       const char *user;
 972       const char *group;
 973       const char *at_console;
 974
 975       if ((e = push_element (parser, ELEMENT_POLICY)) == NULL)
 976         {
 977           BUS_SET_OOM (error);
 978           return FALSE;
 979         }
 980
 981       e->d.policy.type = POLICY_IGNORED;
 982
 983       if (!locate_attributes (parser, "policy",
 984                               attribute_names,
 985                               attribute_values,
 986                               error,
 987                               "context", &context,
 988                               "user", &user,
 989                               "group", &group,
 990                               "at_console", &at_console,
 991                               NULL))
 992         return FALSE;
 993
 994       if (((context && user) ||
 995            (context && group) ||
 996            (context && at_console)) ||
 997            ((user && group) ||
 998            (user && at_console)) ||
 999            (group && at_console) ||
1000           !(context || user || group || at_console))
1001         {
1002           dbus_set_error (error, DBUS_ERROR_FAILED,
1003                           "<policy> element must have exactly one of (context|user|group|at_console) attributes");
1004           return FALSE;
1005         }
1006
1007       if (context != NULL)
1008         {
1009           if (strcmp (context, "default") == 0)
1010             {
1011               e->d.policy.type = POLICY_DEFAULT;
1012             }
1013           else if (strcmp (context, "mandatory") == 0)
1014             {
1015               e->d.policy.type = POLICY_MANDATORY;
1016             }
1017           else
1018             {
1019               dbus_set_error (error, DBUS_ERROR_FAILED,
1020                               "context attribute on <policy> must have the value \"default\" or \"mandatory\", not \"%s\"",
1021                               context);
1022               return FALSE;
1023             }
1024         }
1025       else if (user != NULL)
1026         {
1027           DBusString username;
1028           _dbus_string_init_const (&username, user);
1029
1030           if (_dbus_parse_unix_user_from_config (&username,
1031                                                  &e->d.policy.gid_uid_or_at_console))
1032             e->d.policy.type = POLICY_USER;
1033           else
1034             _dbus_warn ("Unknown username \"%s\" in message bus configuration file\n",
1035                         user);
1036         }
1037       else if (group != NULL)
1038         {
1039           DBusString group_name;
1040           _dbus_string_init_const (&group_name, group);
1041
1042           if (_dbus_parse_unix_group_from_config (&group_name,
1043                                                   &e->d.policy.gid_uid_or_at_console))
1044             e->d.policy.type = POLICY_GROUP;
1045           else
1046             _dbus_warn ("Unknown group \"%s\" in message bus configuration file\n",
1047                         group);
1048         }
1049       else if (at_console != NULL)
1050         {
1051            dbus_bool_t t;
1052            t = (strcmp (at_console, "true") == 0);
1053            if (t || strcmp (at_console, "false") == 0)
1054              {
1055                e->d.policy.gid_uid_or_at_console = t;
1056                e->d.policy.type = POLICY_CONSOLE;
1057              }
1058            else
1059              {
1060                dbus_set_error (error, DBUS_ERROR_FAILED,
1061                               "Unknown value \"%s\" for at_console in message bus configuration file",
1062                               at_console);
1063
1064                return FALSE;
1065              }
1066         }
1067       else
1068         {
1069           _dbus_assert_not_reached ("all <policy> attributes null and we didn't set error");
1070         }
1071
1072       return TRUE;
1073     }
1074   else if (element_type == ELEMENT_LIMIT)
1075     {
1076       Element *e;
1077       const char *name;
1078
1079       if ((e = push_element (parser, ELEMENT_LIMIT)) == NULL)
1080         {
1081           BUS_SET_OOM (error);
1082           return FALSE;
1083         }
1084
1085       if (!locate_attributes (parser, "limit",
1086                               attribute_names,
1087                               attribute_values,
1088                               error,
1089                               "name", &name,
1090                               NULL))
1091         return FALSE;
1092
1093       if (name == NULL)
1094         {
1095           dbus_set_error (error, DBUS_ERROR_FAILED,
1096                           "<limit> element must have a \"name\" attribute");
1097           return FALSE;
1098         }
1099
1100       e->d.limit.name = _dbus_strdup (name);
1101       if (e->d.limit.name == NULL)
1102         {
1103           BUS_SET_OOM (error);
1104           return FALSE;
1105         }
1106
1107       return TRUE;
1108     }
1109   else if (element_type == ELEMENT_SELINUX)
1110     {
1111       if (!check_no_attributes (parser, "selinux", attribute_names, attribute_values, error))
1112         return FALSE;
1113
1114       if (push_element (parser, ELEMENT_SELINUX) == NULL)
1115         {
1116           BUS_SET_OOM (error);
1117           return FALSE;
1118         }
1119
1120       return TRUE;
1121     }
1122   else
1123     {
1124       dbus_set_error (error, DBUS_ERROR_FAILED,
1125                       "Element <%s> not allowed inside <%s> in configuration file",
1126                       element_name, "busconfig");
1127       return FALSE;
1128     }
1129 }
1130
1131 static dbus_bool_t
1132 append_rule_from_element (BusConfigParser   *parser,
1133                           const char        *element_name,
1134                           const char       **attribute_names,
1135                           const char       **attribute_values,
1136                           dbus_bool_t        allow,
1137                           DBusError         *error)
1138 {
1139   const char *log;
1140   const char *send_interface;
1141   const char *send_member;
1142   const char *send_error;
1143   const char *send_destination;
1144   const char *send_path;
1145   const char *send_type;
1146   const char *receive_interface;
1147   const char *receive_member;
1148   const char *receive_error;
1149   const char *receive_sender;
1150   const char *receive_path;
1151   const char *receive_type;
1152   const char *eavesdrop;
1153   const char *send_requested_reply;
1154   const char *receive_requested_reply;
1155   const char *own;
1156   const char *user;
1157   const char *group;
1158
1159   BusPolicyRule *rule;
1160
1161   if (!locate_attributes (parser, element_name,
1162                           attribute_names,
1163                           attribute_values,
1164                           error,
1165                           "send_interface", &send_interface,
1166                           "send_member", &send_member,
1167                           "send_error", &send_error,
1168                           "send_destination", &send_destination,
1169                           "send_path", &send_path,
1170                           "send_type", &send_type,
1171                           "receive_interface", &receive_interface,
1172                           "receive_member", &receive_member,
1173                           "receive_error", &receive_error,
1174                           "receive_sender", &receive_sender,
1175                           "receive_path", &receive_path,
1176                           "receive_type", &receive_type,
1177                           "eavesdrop", &eavesdrop,
1178                           "send_requested_reply", &send_requested_reply,
1179                           "receive_requested_reply", &receive_requested_reply,
1180                           "own", &own,
1181                           "user", &user,
1182                           "group", &group,
1183                           "log", &log,
1184                           NULL))
1185     return FALSE;
1186
1187   if (!(send_interface || send_member || send_error || send_destination ||
1188         send_type || send_path ||
1189         receive_interface || receive_member || receive_error || receive_sender ||
1190         receive_type || receive_path || eavesdrop ||
1191         send_requested_reply || receive_requested_reply ||
1192         own || user || group))
1193     {
1194       dbus_set_error (error, DBUS_ERROR_FAILED,
1195                       "Element <%s> must have one or more attributes",
1196                       element_name);
1197       return FALSE;
1198     }
1199
1200   if ((send_member && (send_interface == NULL && send_path == NULL)) ||
1201       (receive_member && (receive_interface == NULL && receive_path == NULL)))
1202     {
1203       dbus_set_error (error, DBUS_ERROR_FAILED,
1204                       "On element <%s>, if you specify a member you must specify an interface or a path. Keep in mind that not all messages have an interface field.",
1205                       element_name);
1206       return FALSE;
1207     }
1208
1209   /* Allowed combinations of elements are:
1210    *
1211    *   base, must be all send or all receive:
1212    *     nothing
1213    *     interface
1214    *     interface + member
1215    *     error
1216    *
1217    *   base send_ can combine with send_destination, send_path, send_type, send_requested_reply
1218    *   base receive_ with receive_sender, receive_path, receive_type, receive_requested_reply, eavesdrop
1219    *
1220    *   user, group, own must occur alone
1221    *
1222    * Pretty sure the below stuff is broken, FIXME think about it more.
1223    */
1224
1225   if (((send_interface && send_error) ||
1226        (send_interface && receive_interface) ||
1227        (send_interface && receive_member) ||
1228        (send_interface && receive_error) ||
1229        (send_interface && receive_sender) ||
1230        (send_interface && receive_requested_reply) ||
1231        (send_interface && own) ||
1232        (send_interface && user) ||
1233        (send_interface && group)) ||
1234
1235       ((send_member && send_error) ||
1236        (send_member && receive_interface) ||
1237        (send_member && receive_member) ||
1238        (send_member && receive_error) ||
1239        (send_member && receive_sender) ||
1240        (send_member && receive_requested_reply) ||
1241        (send_member && own) ||
1242        (send_member && user) ||
1243        (send_member && group)) ||
1244
1245       ((send_error && receive_interface) ||
1246        (send_error && receive_member) ||
1247        (send_error && receive_error) ||
1248        (send_error && receive_sender) ||
1249        (send_error && receive_requested_reply) ||
1250        (send_error && own) ||
1251        (send_error && user) ||
1252        (send_error && group)) ||
1253
1254       ((send_destination && receive_interface) ||
1255        (send_destination && receive_member) ||
1256        (send_destination && receive_error) ||
1257        (send_destination && receive_sender) ||
1258        (send_destination && receive_requested_reply) ||
1259        (send_destination && own) ||
1260        (send_destination && user) ||
1261        (send_destination && group)) ||
1262
1263       ((send_type && receive_interface) ||
1264        (send_type && receive_member) ||
1265        (send_type && receive_error) ||
1266        (send_type && receive_sender) ||
1267        (send_type && receive_requested_reply) ||
1268        (send_type && own) ||
1269        (send_type && user) ||
1270        (send_type && group)) ||
1271
1272       ((send_path && receive_interface) ||
1273        (send_path && receive_member) ||
1274        (send_path && receive_error) ||
1275        (send_path && receive_sender) ||
1276        (send_path && receive_requested_reply) ||
1277        (send_path && own) ||
1278        (send_path && user) ||
1279        (send_path && group)) ||
1280
1281       ((send_requested_reply && receive_interface) ||
1282        (send_requested_reply && receive_member) ||
1283        (send_requested_reply && receive_error) ||
1284        (send_requested_reply && receive_sender) ||
1285        (send_requested_reply && receive_requested_reply) ||
1286        (send_requested_reply && own) ||
1287        (send_requested_reply && user) ||
1288        (send_requested_reply && group)) ||
1289
1290       ((receive_interface && receive_error) ||
1291        (receive_interface && own) ||
1292        (receive_interface && user) ||
1293        (receive_interface && group)) ||
1294
1295       ((receive_member && receive_error) ||
1296        (receive_member && own) ||
1297        (receive_member && user) ||
1298        (receive_member && group)) ||
1299
1300       ((receive_error && own) ||
1301        (receive_error && user) ||
1302        (receive_error && group)) ||
1303
1304       ((eavesdrop && own) ||
1305        (eavesdrop && user) ||
1306        (eavesdrop && group)) ||
1307
1308       ((receive_requested_reply && own) ||
1309        (receive_requested_reply && user) ||
1310        (receive_requested_reply && group)) ||
1311
1312       ((own && user) ||
1313        (own && group)) ||
1314
1315       ((user && group)))
1316     {
1317       dbus_set_error (error, DBUS_ERROR_FAILED,
1318                       "Invalid combination of attributes on element <%s>",
1319                       element_name);
1320       return FALSE;
1321     }
1322
1323   rule = NULL;
1324
1325   /* In BusPolicyRule, NULL represents wildcard.
1326    * In the config file, '*' represents it.
1327    */
1328 #define IS_WILDCARD(str) ((str) && ((str)[0]) == '*' && ((str)[1]) == '\0')
1329
1330   if (send_interface || send_member || send_error || send_destination ||
1331       send_path || send_type || send_requested_reply)
1332     {
1333       int message_type;
1334
1335       if (IS_WILDCARD (send_interface))
1336         send_interface = NULL;
1337       if (IS_WILDCARD (send_member))
1338         send_member = NULL;
1339       if (IS_WILDCARD (send_error))
1340         send_error = NULL;
1341       if (IS_WILDCARD (send_destination))
1342         send_destination = NULL;
1343       if (IS_WILDCARD (send_path))
1344         send_path = NULL;
1345       if (IS_WILDCARD (send_type))
1346         send_type = NULL;
1347
1348       message_type = DBUS_MESSAGE_TYPE_INVALID;
1349       if (send_type != NULL)
1350         {
1351           message_type = dbus_message_type_from_string (send_type);
1352           if (message_type == DBUS_MESSAGE_TYPE_INVALID)
1353             {
1354               dbus_set_error (error, DBUS_ERROR_FAILED,
1355                               "Bad message type \"%s\"",
1356                               send_type);
1357               return FALSE;
1358             }
1359         }
1360
1361       if (eavesdrop &&
1362           !(strcmp (eavesdrop, "true") == 0 ||
1363             strcmp (eavesdrop, "false") == 0))
1364         {
1365           dbus_set_error (error, DBUS_ERROR_FAILED,
1366                           "Bad value \"%s\" for %s attribute, must be true or false",
1367                           "eavesdrop", eavesdrop);
1368           return FALSE;
1369         }
1370
1371       if (send_requested_reply &&
1372           !(strcmp (send_requested_reply, "true") == 0 ||
1373             strcmp (send_requested_reply, "false") == 0))
1374         {
1375           dbus_set_error (error, DBUS_ERROR_FAILED,
1376                           "Bad value \"%s\" for %s attribute, must be true or false",
1377                           "send_requested_reply", send_requested_reply);
1378           return FALSE;
1379         }
1380
1381       rule = bus_policy_rule_new (BUS_POLICY_RULE_SEND, allow);
1382       if (rule == NULL)
1383         goto nomem;
1384
1385       if (eavesdrop)
1386         rule->d.send.eavesdrop = (strcmp (eavesdrop, "true") == 0);
1387
1388       if (log)
1389         rule->d.send.log = (strcmp (log, "true") == 0);
1390
1391       if (send_requested_reply)
1392         rule->d.send.requested_reply = (strcmp (send_requested_reply, "true") == 0);
1393
1394       rule->d.send.message_type = message_type;
1395       rule->d.send.path = _dbus_strdup (send_path);
1396       rule->d.send.interface = _dbus_strdup (send_interface);
1397       rule->d.send.member = _dbus_strdup (send_member);
1398       rule->d.send.error = _dbus_strdup (send_error);
1399       rule->d.send.destination = _dbus_strdup (send_destination);
1400       if (send_path && rule->d.send.path == NULL)
1401         goto nomem;
1402       if (send_interface && rule->d.send.interface == NULL)
1403         goto nomem;
1404       if (send_member && rule->d.send.member == NULL)
1405         goto nomem;
1406       if (send_error && rule->d.send.error == NULL)
1407         goto nomem;
1408       if (send_destination && rule->d.send.destination == NULL)
1409         goto nomem;
1410     }
1411   else if (receive_interface || receive_member || receive_error || receive_sender ||
1412            receive_path || receive_type || eavesdrop || receive_requested_reply)
1413     {
1414       int message_type;
1415
1416       if (IS_WILDCARD (receive_interface))
1417         receive_interface = NULL;
1418       if (IS_WILDCARD (receive_member))
1419         receive_member = NULL;
1420       if (IS_WILDCARD (receive_error))
1421         receive_error = NULL;
1422       if (IS_WILDCARD (receive_sender))
1423         receive_sender = NULL;
1424       if (IS_WILDCARD (receive_path))
1425         receive_path = NULL;
1426       if (IS_WILDCARD (receive_type))
1427         receive_type = NULL;
1428
1429       message_type = DBUS_MESSAGE_TYPE_INVALID;
1430       if (receive_type != NULL)
1431         {
1432           message_type = dbus_message_type_from_string (receive_type);
1433           if (message_type == DBUS_MESSAGE_TYPE_INVALID)
1434             {
1435               dbus_set_error (error, DBUS_ERROR_FAILED,
1436                               "Bad message type \"%s\"",
1437                               receive_type);
1438               return FALSE;
1439             }
1440         }
1441
1442
1443       if (eavesdrop &&
1444           !(strcmp (eavesdrop, "true") == 0 ||
1445             strcmp (eavesdrop, "false") == 0))
1446         {
1447           dbus_set_error (error, DBUS_ERROR_FAILED,
1448                           "Bad value \"%s\" for %s attribute, must be true or false",
1449                           "eavesdrop", eavesdrop);
1450           return FALSE;
1451         }
1452
1453       if (receive_requested_reply &&
1454           !(strcmp (receive_requested_reply, "true") == 0 ||
1455             strcmp (receive_requested_reply, "false") == 0))
1456         {
1457           dbus_set_error (error, DBUS_ERROR_FAILED,
1458                           "Bad value \"%s\" for %s attribute, must be true or false",
1459                           "receive_requested_reply", receive_requested_reply);
1460           return FALSE;
1461         }
1462
1463       rule = bus_policy_rule_new (BUS_POLICY_RULE_RECEIVE, allow);
1464       if (rule == NULL)
1465         goto nomem;
1466
1467       if (eavesdrop)
1468         rule->d.receive.eavesdrop = (strcmp (eavesdrop, "true") == 0);
1469
1470       if (receive_requested_reply)
1471         rule->d.receive.requested_reply = (strcmp (receive_requested_reply, "true") == 0);
1472
1473       rule->d.receive.message_type = message_type;
1474       rule->d.receive.path = _dbus_strdup (receive_path);
1475       rule->d.receive.interface = _dbus_strdup (receive_interface);
1476       rule->d.receive.member = _dbus_strdup (receive_member);
1477       rule->d.receive.error = _dbus_strdup (receive_error);
1478       rule->d.receive.origin = _dbus_strdup (receive_sender);
1479
1480       if (receive_path && rule->d.receive.path == NULL)
1481         goto nomem;
1482       if (receive_interface && rule->d.receive.interface == NULL)
1483         goto nomem;
1484       if (receive_member && rule->d.receive.member == NULL)
1485         goto nomem;
1486       if (receive_error && rule->d.receive.error == NULL)
1487         goto nomem;
1488       if (receive_sender && rule->d.receive.origin == NULL)
1489         goto nomem;
1490     }
1491   else if (own)
1492     {
1493       rule = bus_policy_rule_new (BUS_POLICY_RULE_OWN, allow);
1494       if (rule == NULL)
1495         goto nomem;
1496
1497       if (IS_WILDCARD (own))
1498         own = NULL;
1499
1500       rule->d.own.service_name = _dbus_strdup (own);
1501       if (own && rule->d.own.service_name == NULL)
1502         goto nomem;
1503     }
1504   else if (user)
1505     {
1506       if (IS_WILDCARD (user))
1507         {
1508           rule = bus_policy_rule_new (BUS_POLICY_RULE_USER, allow);
1509           if (rule == NULL)
1510             goto nomem;
1511
1512           rule->d.user.uid = DBUS_UID_UNSET;
1513         }
1514       else
1515         {
1516           DBusString username;
1517           dbus_uid_t uid;
1518
1519           _dbus_string_init_const (&username, user);
1520
1521           if (_dbus_parse_unix_user_from_config (&username, &uid))
1522             {
1523               rule = bus_policy_rule_new (BUS_POLICY_RULE_USER, allow);
1524               if (rule == NULL)
1525                 goto nomem;
1526
1527               rule->d.user.uid = uid;
1528             }
1529           else
1530             {
1531               _dbus_warn ("Unknown username \"%s\" on element <%s>\n",
1532                           user, element_name);
1533             }
1534         }
1535     }
1536   else if (group)
1537     {
1538       if (IS_WILDCARD (group))
1539         {
1540           rule = bus_policy_rule_new (BUS_POLICY_RULE_GROUP, allow);
1541           if (rule == NULL)
1542             goto nomem;
1543
1544           rule->d.group.gid = DBUS_GID_UNSET;
1545         }
1546       else
1547         {
1548           DBusString groupname;
1549           dbus_gid_t gid;
1550
1551           _dbus_string_init_const (&groupname, group);
1552
1553           if (_dbus_parse_unix_group_from_config (&groupname, &gid))
1554             {
1555               rule = bus_policy_rule_new (BUS_POLICY_RULE_GROUP, allow);
1556               if (rule == NULL)
1557                 goto nomem;
1558
1559               rule->d.group.gid = gid;
1560             }
1561           else
1562             {
1563               _dbus_warn ("Unknown group \"%s\" on element <%s>\n",
1564                           group, element_name);
1565             }
1566         }
1567     }
1568   else
1569     _dbus_assert_not_reached ("Did not handle some combination of attributes on <allow> or <deny>");
1570
1571   if (rule != NULL)
1572     {
1573       Element *pe;
1574
1575       pe = peek_element (parser);
1576       _dbus_assert (pe != NULL);
1577       _dbus_assert (pe->type == ELEMENT_POLICY);
1578
1579       switch (pe->d.policy.type)
1580         {
1581         case POLICY_IGNORED:
1582           /* drop the rule on the floor */
1583           break;
1584
1585         case POLICY_DEFAULT:
1586           if (!bus_policy_append_default_rule (parser->policy, rule))
1587             goto nomem;
1588           break;
1589         case POLICY_MANDATORY:
1590           if (!bus_policy_append_mandatory_rule (parser->policy, rule))
1591             goto nomem;
1592           break;
1593         case POLICY_USER:
1594           if (!BUS_POLICY_RULE_IS_PER_CLIENT (rule))
1595             {
1596               dbus_set_error (error, DBUS_ERROR_FAILED,
1597                               "<%s> rule cannot be per-user because it has bus-global semantics",
1598                               element_name);
1599               goto failed;
1600             }
1601
1602           if (!bus_policy_append_user_rule (parser->policy, pe->d.policy.gid_uid_or_at_console,
1603                                             rule))
1604             goto nomem;
1605           break;
1606         case POLICY_GROUP:
1607           if (!BUS_POLICY_RULE_IS_PER_CLIENT (rule))
1608             {
1609               dbus_set_error (error, DBUS_ERROR_FAILED,
1610                               "<%s> rule cannot be per-group because it has bus-global semantics",
1611                               element_name);
1612               goto failed;
1613             }
1614
1615           if (!bus_policy_append_group_rule (parser->policy, pe->d.policy.gid_uid_or_at_console,
1616                                              rule))
1617             goto nomem;
1618           break;
1619
1620
1621         case POLICY_CONSOLE:
1622           if (!bus_policy_append_console_rule (parser->policy, pe->d.policy.gid_uid_or_at_console,
1623                                                rule))
1624             goto nomem;
1625           break;
1626         }
1627
1628       bus_policy_rule_unref (rule);
1629       rule = NULL;
1630     }
1631
1632   return TRUE;
1633
1634  nomem:
1635   BUS_SET_OOM (error);
1636  failed:
1637   if (rule)
1638     bus_policy_rule_unref (rule);
1639   return FALSE;
1640 }
1641
1642 static dbus_bool_t
1643 start_policy_child (BusConfigParser   *parser,
1644                     const char        *element_name,
1645                     const char       **attribute_names,
1646                     const char       **attribute_values,
1647                     DBusError         *error)
1648 {
1649   if (strcmp (element_name, "allow") == 0)
1650     {
1651       if (!append_rule_from_element (parser, element_name,
1652                                      attribute_names, attribute_values,
1653                                      TRUE, error))
1654         return FALSE;
1655
1656       if (push_element (parser, ELEMENT_ALLOW) == NULL)
1657         {
1658           BUS_SET_OOM (error);
1659           return FALSE;
1660         }
1661
1662       return TRUE;
1663     }
1664   else if (strcmp (element_name, "deny") == 0)
1665     {
1666       if (!append_rule_from_element (parser, element_name,
1667                                      attribute_names, attribute_values,
1668                                      FALSE, error))
1669         return FALSE;
1670
1671       if (push_element (parser, ELEMENT_DENY) == NULL)
1672         {
1673           BUS_SET_OOM (error);
1674           return FALSE;
1675         }
1676
1677       return TRUE;
1678     }
1679   else
1680     {
1681       dbus_set_error (error, DBUS_ERROR_FAILED,
1682                       "Element <%s> not allowed inside <%s> in configuration file",
1683                       element_name, "policy");
1684       return FALSE;
1685     }
1686 }
1687
1688 static dbus_bool_t
1689 start_selinux_child (BusConfigParser   *parser,
1690                      const char        *element_name,
1691                      const char       **attribute_names,
1692                      const char       **attribute_values,
1693                      DBusError         *error)
1694 {
1695   char *own_copy;
1696   char *context_copy;
1697
1698   own_copy = NULL;
1699   context_copy = NULL;
1700
1701   if (strcmp (element_name, "associate") == 0)
1702     {
1703       const char *own;
1704       const char *context;
1705
1706       if (!locate_attributes (parser, "associate",
1707                               attribute_names,
1708                               attribute_values,
1709                               error,
1710                               "own", &own,
1711                               "context", &context,
1712                               NULL))
1713         return FALSE;
1714
1715       if (push_element (parser, ELEMENT_ASSOCIATE) == NULL)
1716         {
1717           BUS_SET_OOM (error);
1718           return FALSE;
1719         }
1720
1721       if (own == NULL || context == NULL)
1722         {
1723           dbus_set_error (error, DBUS_ERROR_FAILED,
1724                           "Element <associate> must have attributes own=\"<servicename>\" and context=\"<selinux context>\"");
1725           return FALSE;
1726         }
1727
1728       own_copy = _dbus_strdup (own);
1729       if (own_copy == NULL)
1730         goto oom;
1731       context_copy = _dbus_strdup (context);
1732       if (context_copy == NULL)
1733         goto oom;
1734
1735       if (!_dbus_hash_table_insert_string (parser->service_context_table,
1736                                            own_copy, context_copy))
1737         goto oom;
1738
1739       return TRUE;
1740     }
1741   else
1742     {
1743       dbus_set_error (error, DBUS_ERROR_FAILED,
1744                       "Element <%s> not allowed inside <%s> in configuration file",
1745                       element_name, "selinux");
1746       return FALSE;
1747     }
1748
1749  oom:
1750   if (own_copy)
1751     dbus_free (own_copy);
1752
1753   if (context_copy)
1754     dbus_free (context_copy);
1755
1756   BUS_SET_OOM (error);
1757   return FALSE;
1758 }
1759
1760 dbus_bool_t
1761 bus_config_parser_start_element (BusConfigParser   *parser,
1762                                  const char        *element_name,
1763                                  const char       **attribute_names,
1764                                  const char       **attribute_values,
1765                                  DBusError         *error)
1766 {
1767   ElementType t;
1768
1769   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1770
1771   /* printf ("START: %s\n", element_name); */
1772
1773   t = top_element_type (parser);
1774
1775   if (t == ELEMENT_NONE)
1776     {
1777       if (strcmp (element_name, "busconfig") == 0)
1778         {
1779           if (!check_no_attributes (parser, "busconfig", attribute_names, attribute_values, error))
1780             return FALSE;
1781
1782           if (push_element (parser, ELEMENT_BUSCONFIG) == NULL)
1783             {
1784               BUS_SET_OOM (error);
1785               return FALSE;
1786             }
1787
1788           return TRUE;
1789         }
1790       else
1791         {
1792           dbus_set_error (error, DBUS_ERROR_FAILED,
1793                           "Unknown element <%s> at root of configuration file",
1794                           element_name);
1795           return FALSE;
1796         }
1797     }
1798   else if (t == ELEMENT_BUSCONFIG)
1799     {
1800       return start_busconfig_child (parser, element_name,
1801                                     attribute_names, attribute_values,
1802                                     error);
1803     }
1804   else if (t == ELEMENT_POLICY)
1805     {
1806       return start_policy_child (parser, element_name,
1807                                  attribute_names, attribute_values,
1808                                  error);
1809     }
1810   else if (t == ELEMENT_SELINUX)
1811     {
1812       return start_selinux_child (parser, element_name,
1813                                   attribute_names, attribute_values,
1814                                   error);
1815     }
1816   else
1817     {
1818       dbus_set_error (error, DBUS_ERROR_FAILED,
1819                       "Element <%s> is not allowed in this context",
1820                       element_name);
1821       return FALSE;
1822     }
1823 }
1824
1825 static dbus_bool_t
1826 set_limit (BusConfigParser *parser,
1827            const char      *name,
1828            long             value,
1829            DBusError       *error)
1830 {
1831   dbus_bool_t must_be_positive;
1832   dbus_bool_t must_be_int;
1833
1834   must_be_int = FALSE;
1835   must_be_positive = FALSE;
1836
1837   if (strcmp (name, "max_incoming_bytes") == 0)
1838     {
1839       must_be_positive = TRUE;
1840       parser->limits.max_incoming_bytes = value;
1841     }
1842   else if (strcmp (name, "max_incoming_unix_fds") == 0)
1843     {
1844       must_be_positive = TRUE;
1845       parser->limits.max_incoming_unix_fds = value;
1846     }
1847   else if (strcmp (name, "max_outgoing_bytes") == 0)
1848     {
1849       must_be_positive = TRUE;
1850       parser->limits.max_outgoing_bytes = value;
1851     }
1852   else if (strcmp (name, "max_outgoing_unix_fds") == 0)
1853     {
1854       must_be_positive = TRUE;
1855       parser->limits.max_outgoing_unix_fds = value;
1856     }
1857   else if (strcmp (name, "max_message_size") == 0)
1858     {
1859       must_be_positive = TRUE;
1860       parser->limits.max_message_size = value;
1861     }
1862   else if (strcmp (name, "max_message_unix_fds") == 0)
1863     {
1864       must_be_positive = TRUE;
1865       parser->limits.max_message_unix_fds = value;
1866     }
1867   else if (strcmp (name, "service_start_timeout") == 0)
1868     {
1869       must_be_positive = TRUE;
1870       must_be_int = TRUE;
1871       parser->limits.activation_timeout = value;
1872     }
1873   else if (strcmp (name, "auth_timeout") == 0)
1874     {
1875       must_be_positive = TRUE;
1876       must_be_int = TRUE;
1877       parser->limits.auth_timeout = value;
1878     }
1879   else if (strcmp (name, "reply_timeout") == 0)
1880     {
1881       must_be_positive = TRUE;
1882       must_be_int = TRUE;
1883       parser->limits.reply_timeout = value;
1884     }
1885   else if (strcmp (name, "max_completed_connections") == 0)
1886     {
1887       must_be_positive = TRUE;
1888       must_be_int = TRUE;
1889       parser->limits.max_completed_connections = value;
1890     }
1891   else if (strcmp (name, "max_incomplete_connections") == 0)
1892     {
1893       must_be_positive = TRUE;
1894       must_be_int = TRUE;
1895       parser->limits.max_incomplete_connections = value;
1896     }
1897   else if (strcmp (name, "max_connections_per_user") == 0)
1898     {
1899       must_be_positive = TRUE;
1900       must_be_int = TRUE;
1901       parser->limits.max_connections_per_user = value;
1902     }
1903   else if (strcmp (name, "max_pending_service_starts") == 0)
1904     {
1905       must_be_positive = TRUE;
1906       must_be_int = TRUE;
1907       parser->limits.max_pending_activations = value;
1908     }
1909   else if (strcmp (name, "max_names_per_connection") == 0)
1910     {
1911       must_be_positive = TRUE;
1912       must_be_int = TRUE;
1913       parser->limits.max_services_per_connection = value;
1914     }
1915   else if (strcmp (name, "max_match_rules_per_connection") == 0)
1916     {
1917       must_be_positive = TRUE;
1918       must_be_int = TRUE;
1919       parser->limits.max_match_rules_per_connection = value;
1920     }
1921   else if (strcmp (name, "max_replies_per_connection") == 0)
1922     {
1923       must_be_positive = TRUE;
1924       must_be_int = TRUE;
1925       parser->limits.max_replies_per_connection = value;
1926     }
1927   else
1928     {
1929       dbus_set_error (error, DBUS_ERROR_FAILED,
1930                       "There is no limit called \"%s\"\n",
1931                       name);
1932       return FALSE;
1933     }
1934
1935   if (must_be_positive && value < 0)
1936     {
1937       dbus_set_error (error, DBUS_ERROR_FAILED,
1938                       "<limit name=\"%s\"> must be a positive number\n",
1939                       name);
1940       return FALSE;
1941     }
1942
1943   if (must_be_int &&
1944       (value < _DBUS_INT_MIN || value > _DBUS_INT_MAX))
1945     {
1946       dbus_set_error (error, DBUS_ERROR_FAILED,
1947                       "<limit name=\"%s\"> value is too large\n",
1948                       name);
1949       return FALSE;
1950     }
1951
1952   return TRUE;
1953 }
1954
1955 dbus_bool_t
1956 bus_config_parser_end_element (BusConfigParser   *parser,
1957                                const char        *element_name,
1958                                DBusError         *error)
1959 {
1960   ElementType t;
1961   const char *n;
1962   Element *e;
1963
1964   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1965
1966   /* printf ("END: %s\n", element_name); */
1967
1968   t = top_element_type (parser);
1969
1970   if (t == ELEMENT_NONE)
1971     {
1972       /* should probably be an assertion failure but
1973        * being paranoid about XML parsers
1974        */
1975       dbus_set_error (error, DBUS_ERROR_FAILED,
1976                       "XML parser ended element with no element on the stack");
1977       return FALSE;
1978     }
1979
1980   n = bus_config_parser_element_type_to_name (t);
1981   _dbus_assert (n != NULL);
1982   if (strcmp (n, element_name) != 0)
1983     {
1984       /* should probably be an assertion failure but
1985        * being paranoid about XML parsers
1986        */
1987       dbus_set_error (error, DBUS_ERROR_FAILED,
1988                       "XML element <%s> ended but topmost element on the stack was <%s>",
1989                       element_name, n);
1990       return FALSE;
1991     }
1992
1993   e = peek_element (parser);
1994   _dbus_assert (e != NULL);
1995
1996   switch (e->type)
1997     {
1998     case ELEMENT_NONE:
1999       _dbus_assert_not_reached ("element in stack has no type");
2000       break;
2001
2002     case ELEMENT_INCLUDE:
2003     case ELEMENT_USER:
2004     case ELEMENT_TYPE:
2005     case ELEMENT_LISTEN:
2006     case ELEMENT_PIDFILE:
2007     case ELEMENT_AUTH:
2008     case ELEMENT_SERVICEDIR:
2009     case ELEMENT_SERVICEHELPER:
2010     case ELEMENT_INCLUDEDIR:
2011     case ELEMENT_LIMIT:
2012       if (!e->had_content)
2013         {
2014           dbus_set_error (error, DBUS_ERROR_FAILED,
2015                           "XML element <%s> was expected to have content inside it",
2016                           bus_config_parser_element_type_to_name (e->type));
2017           return FALSE;
2018         }
2019
2020       if (e->type == ELEMENT_LIMIT)
2021         {
2022           if (!set_limit (parser, e->d.limit.name, e->d.limit.value,
2023                           error))
2024             return FALSE;
2025         }
2026       break;
2027
2028     case ELEMENT_BUSCONFIG:
2029     case ELEMENT_POLICY:
2030     case ELEMENT_ALLOW:
2031     case ELEMENT_DENY:
2032     case ELEMENT_FORK:
2033     case ELEMENT_SYSLOG:
2034     case ELEMENT_KEEP_UMASK:
2035     case ELEMENT_SELINUX:
2036     case ELEMENT_ASSOCIATE:
2037     case ELEMENT_STANDARD_SESSION_SERVICEDIRS:
2038     case ELEMENT_STANDARD_SYSTEM_SERVICEDIRS:
2039     case ELEMENT_ALLOW_ANONYMOUS:
2040       break;
2041     }
2042
2043   pop_element (parser);
2044
2045   return TRUE;
2046 }
2047
2048 static dbus_bool_t
2049 all_whitespace (const DBusString *str)
2050 {
2051   int i;
2052
2053   _dbus_string_skip_white (str, 0, &i);
2054
2055   return i == _dbus_string_get_length (str);
2056 }
2057
2058 static dbus_bool_t
2059 make_full_path (const DBusString *basedir,
2060                 const DBusString *filename,
2061                 DBusString       *full_path)
2062 {
2063   if (_dbus_path_is_absolute (filename))
2064     {
2065       return _dbus_string_copy (filename, 0, full_path, 0);
2066     }
2067   else
2068     {
2069       if (!_dbus_string_copy (basedir, 0, full_path, 0))
2070         return FALSE;
2071
2072       if (!_dbus_concat_dir_and_file (full_path, filename))
2073         return FALSE;
2074
2075       return TRUE;
2076     }
2077 }
2078
2079 static dbus_bool_t
2080 include_file (BusConfigParser   *parser,
2081               const DBusString  *filename,
2082               dbus_bool_t        ignore_missing,
2083               DBusError         *error)
2084 {
2085   /* FIXME good test case for this would load each config file in the
2086    * test suite both alone, and as an include, and check
2087    * that the result is the same
2088    */
2089   BusConfigParser *included;
2090   const char *filename_str;
2091   DBusError tmp_error;
2092
2093   dbus_error_init (&tmp_error);
2094
2095   filename_str = _dbus_string_get_const_data (filename);
2096
2097   /* Check to make sure this file hasn't already been included. */
2098   if (seen_include (parser, filename))
2099     {
2100       dbus_set_error (error, DBUS_ERROR_FAILED,
2101                       "Circular inclusion of file '%s'",
2102                       filename_str);
2103       return FALSE;
2104     }
2105
2106   if (! _dbus_list_append (&parser->included_files, (void *) filename_str))
2107     {
2108       BUS_SET_OOM (error);
2109       return FALSE;
2110     }
2111
2112   /* Since parser is passed in as the parent, included
2113      inherits parser's limits. */
2114   included = bus_config_load (filename, FALSE, parser, &tmp_error);
2115
2116   _dbus_list_pop_last (&parser->included_files);
2117
2118   if (included == NULL)
2119     {
2120       _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
2121
2122       if (dbus_error_has_name (&tmp_error, DBUS_ERROR_FILE_NOT_FOUND) &&
2123           ignore_missing)
2124         {
2125           dbus_error_free (&tmp_error);
2126           return TRUE;
2127         }
2128       else
2129         {
2130           dbus_move_error (&tmp_error, error);
2131           return FALSE;
2132         }
2133     }
2134   else
2135     {
2136       _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
2137
2138       if (!merge_included (parser, included, error))
2139         {
2140           bus_config_parser_unref (included);
2141           return FALSE;
2142         }
2143
2144       /* Copy included's limits back to parser. */
2145       parser->limits = included->limits;
2146
2147       bus_config_parser_unref (included);
2148       return TRUE;
2149     }
2150 }
2151
2152 static dbus_bool_t
2153 servicehelper_path (BusConfigParser   *parser,
2154                     const DBusString  *filename,
2155                     DBusError         *error)
2156 {
2157   const char *filename_str;
2158   char *servicehelper;
2159
2160   filename_str = _dbus_string_get_const_data (filename);
2161
2162   /* copy to avoid overwriting with NULL on OOM */
2163   servicehelper = _dbus_strdup (filename_str);
2164
2165   /* check for OOM */
2166   if (servicehelper == NULL)
2167     {
2168       BUS_SET_OOM (error);
2169       return FALSE;
2170     }
2171
2172   /* save the latest servicehelper only if not OOM */
2173   dbus_free (parser->servicehelper);
2174   parser->servicehelper = servicehelper;
2175
2176   /* We don't check whether the helper exists; instead we
2177    * would just fail to ever activate anything if it doesn't.
2178    * This allows an admin to fix the problem if it doesn't exist.
2179    * It also allows the parser test suite to successfully parse
2180    * test cases without installing the helper. ;-)
2181    */
2182
2183   return TRUE;
2184 }
2185
2186 static dbus_bool_t
2187 include_dir (BusConfigParser   *parser,
2188              const DBusString  *dirname,
2189              DBusError         *error)
2190 {
2191   DBusString filename;
2192   dbus_bool_t retval;
2193   DBusError tmp_error;
2194   DBusDirIter *dir;
2195   char *s;
2196
2197   if (!_dbus_string_init (&filename))
2198     {
2199       BUS_SET_OOM (error);
2200       return FALSE;
2201     }
2202
2203   retval = FALSE;
2204
2205   dir = _dbus_directory_open (dirname, error);
2206
2207   if (dir == NULL)
2208     goto failed;
2209
2210   dbus_error_init (&tmp_error);
2211   while (_dbus_directory_get_next_file (dir, &filename, &tmp_error))
2212     {
2213       DBusString full_path;
2214
2215       if (!_dbus_string_init (&full_path))
2216         {
2217           BUS_SET_OOM (error);
2218           goto failed;
2219         }
2220
2221       if (!_dbus_string_copy (dirname, 0, &full_path, 0))
2222         {
2223           BUS_SET_OOM (error);
2224           _dbus_string_free (&full_path);
2225           goto failed;
2226         }
2227
2228       if (!_dbus_concat_dir_and_file (&full_path, &filename))
2229         {
2230           BUS_SET_OOM (error);
2231           _dbus_string_free (&full_path);
2232           goto failed;
2233         }
2234
2235       if (_dbus_string_ends_with_c_str (&full_path, ".conf"))
2236         {
2237           if (!include_file (parser, &full_path, TRUE, error))
2238             {
2239               _dbus_string_free (&full_path);
2240               goto failed;
2241             }
2242         }
2243
2244       _dbus_string_free (&full_path);
2245     }
2246
2247   if (dbus_error_is_set (&tmp_error))
2248     {
2249       dbus_move_error (&tmp_error, error);
2250       goto failed;
2251     }
2252
2253
2254   if (!_dbus_string_copy_data (dirname, &s))
2255     {
2256       BUS_SET_OOM (error);
2257       goto failed;
2258     }
2259
2260   if (!_dbus_list_append (&parser->conf_dirs, s))
2261     {
2262       dbus_free (s);
2263       BUS_SET_OOM (error);
2264       goto failed;
2265     }
2266
2267   retval = TRUE;
2268
2269  failed:
2270   _dbus_string_free (&filename);
2271
2272   if (dir)
2273     _dbus_directory_close (dir);
2274
2275   return retval;
2276 }
2277
2278 dbus_bool_t
2279 bus_config_parser_content (BusConfigParser   *parser,
2280                            const DBusString  *content,
2281                            DBusError         *error)
2282 {
2283   Element *e;
2284
2285   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2286
2287 #if 0
2288   {
2289     const char *c_str;
2290
2291     _dbus_string_get_const_data (content, &c_str);
2292
2293     printf ("CONTENT %d bytes: %s\n", _dbus_string_get_length (content), c_str);
2294   }
2295 #endif
2296
2297   e = peek_element (parser);
2298   if (e == NULL)
2299     {
2300       dbus_set_error (error, DBUS_ERROR_FAILED,
2301                       "Text content outside of any XML element in configuration file");
2302       return FALSE;
2303     }
2304   else if (e->had_content)
2305     {
2306       _dbus_assert_not_reached ("Element had multiple content blocks");
2307       return FALSE;
2308     }
2309
2310   switch (top_element_type (parser))
2311     {
2312     case ELEMENT_NONE:
2313       _dbus_assert_not_reached ("element at top of stack has no type");
2314       return FALSE;
2315
2316     case ELEMENT_BUSCONFIG:
2317     case ELEMENT_POLICY:
2318     case ELEMENT_ALLOW:
2319     case ELEMENT_DENY:
2320     case ELEMENT_FORK:
2321     case ELEMENT_SYSLOG:
2322     case ELEMENT_KEEP_UMASK:
2323     case ELEMENT_STANDARD_SESSION_SERVICEDIRS:
2324     case ELEMENT_STANDARD_SYSTEM_SERVICEDIRS:
2325     case ELEMENT_ALLOW_ANONYMOUS:
2326     case ELEMENT_SELINUX:
2327     case ELEMENT_ASSOCIATE:
2328       if (all_whitespace (content))
2329         return TRUE;
2330       else
2331         {
2332           dbus_set_error (error, DBUS_ERROR_FAILED,
2333                           "No text content expected inside XML element %s in configuration file",
2334                           bus_config_parser_element_type_to_name (top_element_type (parser)));
2335           return FALSE;
2336         }
2337
2338     case ELEMENT_PIDFILE:
2339       {
2340         char *s;
2341
2342         e->had_content = TRUE;
2343
2344         if (!_dbus_string_copy_data (content, &s))
2345           goto nomem;
2346
2347         dbus_free (parser->pidfile);
2348         parser->pidfile = s;
2349       }
2350       break;
2351
2352     case ELEMENT_INCLUDE:
2353       {
2354         DBusString full_path, selinux_policy_root;
2355
2356         e->had_content = TRUE;
2357
2358         if (e->d.include.if_selinux_enabled
2359             && !bus_selinux_enabled ())
2360           break;
2361
2362         if (!_dbus_string_init (&full_path))
2363           goto nomem;
2364
2365         if (e->d.include.selinux_root_relative)
2366           {
2367             if (!bus_selinux_get_policy_root ())
2368               {
2369                 dbus_set_error (error, DBUS_ERROR_FAILED,
2370                                 "Could not determine SELinux policy root for relative inclusion");
2371                 _dbus_string_free (&full_path);
2372                 return FALSE;
2373               }
2374             _dbus_string_init_const (&selinux_policy_root,
2375                                      bus_selinux_get_policy_root ());
2376             if (!make_full_path (&selinux_policy_root, content, &full_path))
2377               {
2378                 _dbus_string_free (&full_path);
2379                 goto nomem;
2380               }
2381           }
2382         else if (!make_full_path (&parser->basedir, content, &full_path))
2383           {
2384             _dbus_string_free (&full_path);
2385             goto nomem;
2386           }
2387
2388         if (!include_file (parser, &full_path,
2389                            e->d.include.ignore_missing, error))
2390           {
2391             _dbus_string_free (&full_path);
2392             return FALSE;
2393           }
2394
2395         _dbus_string_free (&full_path);
2396       }
2397       break;
2398
2399     case ELEMENT_SERVICEHELPER:
2400       {
2401         DBusString full_path;
2402
2403         e->had_content = TRUE;
2404
2405         if (!_dbus_string_init (&full_path))
2406           goto nomem;
2407
2408         if (!make_full_path (&parser->basedir, content, &full_path))
2409           {
2410             _dbus_string_free (&full_path);
2411             goto nomem;
2412           }
2413
2414         if (!servicehelper_path (parser, &full_path, error))
2415           {
2416             _dbus_string_free (&full_path);
2417             return FALSE;
2418           }
2419
2420         _dbus_string_free (&full_path);
2421       }
2422       break;
2423
2424     case ELEMENT_INCLUDEDIR:
2425       {
2426         DBusString full_path;
2427
2428         e->had_content = TRUE;
2429
2430         if (!_dbus_string_init (&full_path))
2431           goto nomem;
2432
2433         if (!make_full_path (&parser->basedir, content, &full_path))
2434           {
2435             _dbus_string_free (&full_path);
2436             goto nomem;
2437           }
2438
2439         if (!include_dir (parser, &full_path, error))
2440           {
2441             _dbus_string_free (&full_path);
2442             return FALSE;
2443           }
2444
2445         _dbus_string_free (&full_path);
2446       }
2447       break;
2448
2449     case ELEMENT_USER:
2450       {
2451         char *s;
2452
2453         e->had_content = TRUE;
2454
2455         if (!_dbus_string_copy_data (content, &s))
2456           goto nomem;
2457
2458         dbus_free (parser->user);
2459         parser->user = s;
2460       }
2461       break;
2462
2463     case ELEMENT_TYPE:
2464       {
2465         char *s;
2466
2467         e->had_content = TRUE;
2468
2469         if (!_dbus_string_copy_data (content, &s))
2470           goto nomem;
2471
2472         dbus_free (parser->bus_type);
2473         parser->bus_type = s;
2474       }
2475       break;
2476
2477     case ELEMENT_LISTEN:
2478       {
2479         char *s;
2480
2481         e->had_content = TRUE;
2482
2483         if (!_dbus_string_copy_data (content, &s))
2484           goto nomem;
2485
2486         if (!_dbus_list_append (&parser->listen_on,
2487                                 s))
2488           {
2489             dbus_free (s);
2490             goto nomem;
2491           }
2492       }
2493       break;
2494
2495     case ELEMENT_AUTH:
2496       {
2497         char *s;
2498
2499         e->had_content = TRUE;
2500
2501         if (!_dbus_string_copy_data (content, &s))
2502           goto nomem;
2503
2504         if (!_dbus_list_append (&parser->mechanisms,
2505                                 s))
2506           {
2507             dbus_free (s);
2508             goto nomem;
2509           }
2510       }
2511       break;
2512
2513     case ELEMENT_SERVICEDIR:
2514       {
2515         char *s;
2516         DBusString full_path;
2517
2518         e->had_content = TRUE;
2519
2520         if (!_dbus_string_init (&full_path))
2521           goto nomem;
2522
2523         if (!make_full_path (&parser->basedir, content, &full_path))
2524           {
2525             _dbus_string_free (&full_path);
2526             goto nomem;
2527           }
2528
2529         if (!_dbus_string_copy_data (&full_path, &s))
2530           {
2531             _dbus_string_free (&full_path);
2532             goto nomem;
2533           }
2534
2535         /* _only_ extra session directories can be specified */
2536         if (!service_dirs_append_unique_or_free (&parser->service_dirs, s))
2537           {
2538             _dbus_string_free (&full_path);
2539             dbus_free (s);
2540             goto nomem;
2541           }
2542
2543         _dbus_string_free (&full_path);
2544       }
2545       break;
2546
2547     case ELEMENT_LIMIT:
2548       {
2549         long val;
2550
2551         e->had_content = TRUE;
2552
2553         val = 0;
2554         if (!_dbus_string_parse_int (content, 0, &val, NULL))
2555           {
2556             dbus_set_error (error, DBUS_ERROR_FAILED,
2557                             "<limit name=\"%s\"> element has invalid value (could not parse as integer)",
2558                             e->d.limit.name);
2559             return FALSE;
2560           }
2561
2562         e->d.limit.value = val;
2563
2564         _dbus_verbose ("Loaded value %ld for limit %s\n",
2565                        e->d.limit.value,
2566                        e->d.limit.name);
2567       }
2568       break;
2569     }
2570
2571   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2572   return TRUE;
2573
2574  nomem:
2575   BUS_SET_OOM (error);
2576   return FALSE;
2577 }
2578
2579 dbus_bool_t
2580 bus_config_parser_finished (BusConfigParser   *parser,
2581                             DBusError         *error)
2582 {
2583   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2584
2585   if (parser->stack != NULL)
2586     {
2587       dbus_set_error (error, DBUS_ERROR_FAILED,
2588                       "Element <%s> was not closed in configuration file",
2589                       bus_config_parser_element_type_to_name (top_element_type (parser)));
2590
2591       return FALSE;
2592     }
2593
2594   if (parser->is_toplevel && parser->listen_on == NULL)
2595     {
2596       dbus_set_error (error, DBUS_ERROR_FAILED,
2597                       "Configuration file needs one or more <listen> elements giving addresses");
2598       return FALSE;
2599     }
2600
2601   return TRUE;
2602 }
2603
2604 const char*
2605 bus_config_parser_get_user (BusConfigParser *parser)
2606 {
2607   return parser->user;
2608 }
2609
2610 const char*
2611 bus_config_parser_get_type (BusConfigParser *parser)
2612 {
2613   return parser->bus_type;
2614 }
2615
2616 DBusList**
2617 bus_config_parser_get_addresses (BusConfigParser *parser)
2618 {
2619   return &parser->listen_on;
2620 }
2621
2622 DBusList**
2623 bus_config_parser_get_mechanisms (BusConfigParser *parser)
2624 {
2625   return &parser->mechanisms;
2626 }
2627
2628 DBusList**
2629 bus_config_parser_get_service_dirs (BusConfigParser *parser)
2630 {
2631   return &parser->service_dirs;
2632 }
2633
2634 DBusList**
2635 bus_config_parser_get_conf_dirs (BusConfigParser *parser)
2636 {
2637   return &parser->conf_dirs;
2638 }
2639
2640 dbus_bool_t
2641 bus_config_parser_get_fork (BusConfigParser   *parser)
2642 {
2643   return parser->fork;
2644 }
2645
2646 dbus_bool_t
2647 bus_config_parser_get_syslog (BusConfigParser   *parser)
2648 {
2649   return parser->syslog;
2650 }
2651
2652 dbus_bool_t
2653 bus_config_parser_get_keep_umask (BusConfigParser   *parser)
2654 {
2655   return parser->keep_umask;
2656 }
2657
2658 dbus_bool_t
2659 bus_config_parser_get_allow_anonymous (BusConfigParser   *parser)
2660 {
2661   return parser->allow_anonymous;
2662 }
2663
2664 const char *
2665 bus_config_parser_get_pidfile (BusConfigParser   *parser)
2666 {
2667   return parser->pidfile;
2668 }
2669
2670 const char *
2671 bus_config_parser_get_servicehelper (BusConfigParser   *parser)
2672 {
2673   return parser->servicehelper;
2674 }
2675
2676 BusPolicy*
2677 bus_config_parser_steal_policy (BusConfigParser *parser)
2678 {
2679   BusPolicy *policy;
2680
2681   _dbus_assert (parser->policy != NULL); /* can only steal the policy 1 time */
2682
2683   policy = parser->policy;
2684
2685   parser->policy = NULL;
2686
2687   return policy;
2688 }
2689
2690 /* Overwrite any limits that were set in the configuration file */
2691 void
2692 bus_config_parser_get_limits (BusConfigParser *parser,
2693                               BusLimits       *limits)
2694 {
2695   *limits = parser->limits;
2696 }
2697
2698 DBusHashTable*
2699 bus_config_parser_steal_service_context_table (BusConfigParser *parser)
2700 {
2701   DBusHashTable *table;
2702
2703   _dbus_assert (parser->service_context_table != NULL); /* can only steal once */
2704
2705   table = parser->service_context_table;
2706
2707   parser->service_context_table = NULL;
2708
2709   return table;
2710 }
2711
2712 #ifdef DBUS_BUILD_TESTS
2713 #include <stdio.h>
2714
2715 typedef enum
2716 {
2717   VALID,
2718   INVALID,
2719   UNKNOWN
2720 } Validity;
2721
2722 static dbus_bool_t
2723 do_load (const DBusString *full_path,
2724          Validity          validity,
2725          dbus_bool_t       oom_possible)
2726 {
2727   BusConfigParser *parser;
2728   DBusError error;
2729
2730   dbus_error_init (&error);
2731
2732   parser = bus_config_load (full_path, TRUE, NULL, &error);
2733   if (parser == NULL)
2734     {
2735       _DBUS_ASSERT_ERROR_IS_SET (&error);
2736
2737       if (oom_possible &&
2738           dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY))
2739         {
2740           _dbus_verbose ("Failed to load valid file due to OOM\n");
2741           dbus_error_free (&error);
2742           return TRUE;
2743         }
2744       else if (validity == VALID)
2745         {
2746           _dbus_warn ("Failed to load valid file but still had memory: %s\n",
2747                       error.message);
2748
2749           dbus_error_free (&error);
2750           return FALSE;
2751         }
2752       else
2753         {
2754           dbus_error_free (&error);
2755           return TRUE;
2756         }
2757     }
2758   else
2759     {
2760       _DBUS_ASSERT_ERROR_IS_CLEAR (&error);
2761
2762       bus_config_parser_unref (parser);
2763
2764       if (validity == INVALID)
2765         {
2766           _dbus_warn ("Accepted invalid file\n");
2767           return FALSE;
2768         }
2769
2770       return TRUE;
2771     }
2772 }
2773
2774 typedef struct
2775 {
2776   const DBusString *full_path;
2777   Validity          validity;
2778 } LoaderOomData;
2779
2780 static dbus_bool_t
2781 check_loader_oom_func (void *data)
2782 {
2783   LoaderOomData *d = data;
2784
2785   return do_load (d->full_path, d->validity, TRUE);
2786 }
2787
2788 static dbus_bool_t
2789 process_test_valid_subdir (const DBusString *test_base_dir,
2790                            const char       *subdir,
2791                            Validity          validity)
2792 {
2793   DBusString test_directory;
2794   DBusString filename;
2795   DBusDirIter *dir;
2796   dbus_bool_t retval;
2797   DBusError error;
2798
2799   retval = FALSE;
2800   dir = NULL;
2801
2802   if (!_dbus_string_init (&test_directory))
2803     _dbus_assert_not_reached ("didn't allocate test_directory\n");
2804
2805   _dbus_string_init_const (&filename, subdir);
2806
2807   if (!_dbus_string_copy (test_base_dir, 0,
2808                           &test_directory, 0))
2809     _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
2810
2811   if (!_dbus_concat_dir_and_file (&test_directory, &filename))
2812     _dbus_assert_not_reached ("couldn't allocate full path");
2813
2814   _dbus_string_free (&filename);
2815   if (!_dbus_string_init (&filename))
2816     _dbus_assert_not_reached ("didn't allocate filename string\n");
2817
2818   dbus_error_init (&error);
2819   dir = _dbus_directory_open (&test_directory, &error);
2820   if (dir == NULL)
2821     {
2822       _dbus_warn ("Could not open %s: %s\n",
2823                   _dbus_string_get_const_data (&test_directory),
2824                   error.message);
2825       dbus_error_free (&error);
2826       goto failed;
2827     }
2828
2829   if (validity == VALID)
2830     printf ("Testing valid files:\n");
2831   else if (validity == INVALID)
2832     printf ("Testing invalid files:\n");
2833   else
2834     printf ("Testing unknown files:\n");
2835
2836  next:
2837   while (_dbus_directory_get_next_file (dir, &filename, &error))
2838     {
2839       DBusString full_path;
2840       LoaderOomData d;
2841
2842       if (!_dbus_string_init (&full_path))
2843         _dbus_assert_not_reached ("couldn't init string");
2844
2845       if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
2846         _dbus_assert_not_reached ("couldn't copy dir to full_path");
2847
2848       if (!_dbus_concat_dir_and_file (&full_path, &filename))
2849         _dbus_assert_not_reached ("couldn't concat file to dir");
2850
2851       if (!_dbus_string_ends_with_c_str (&full_path, ".conf"))
2852         {
2853           _dbus_verbose ("Skipping non-.conf file %s\n",
2854                          _dbus_string_get_const_data (&filename));
2855           _dbus_string_free (&full_path);
2856           goto next;
2857         }
2858
2859       printf ("    %s\n", _dbus_string_get_const_data (&filename));
2860
2861       _dbus_verbose (" expecting %s\n",
2862                      validity == VALID ? "valid" :
2863                      (validity == INVALID ? "invalid" :
2864                       (validity == UNKNOWN ? "unknown" : "???")));
2865
2866       d.full_path = &full_path;
2867       d.validity = validity;
2868
2869       /* FIXME hackaround for an expat problem, see
2870        * https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=124747
2871        * http://freedesktop.org/pipermail/dbus/2004-May/001153.html
2872        */
2873       /* if (!_dbus_test_oom_handling ("config-loader", check_loader_oom_func, &d)) */
2874       if (!check_loader_oom_func (&d))
2875         _dbus_assert_not_reached ("test failed");
2876
2877       _dbus_string_free (&full_path);
2878     }
2879
2880   if (dbus_error_is_set (&error))
2881     {
2882       _dbus_warn ("Could not get next file in %s: %s\n",
2883                   _dbus_string_get_const_data (&test_directory),
2884                   error.message);
2885       dbus_error_free (&error);
2886       goto failed;
2887     }
2888
2889   retval = TRUE;
2890
2891  failed:
2892
2893   if (dir)
2894     _dbus_directory_close (dir);
2895   _dbus_string_free (&test_directory);
2896   _dbus_string_free (&filename);
2897
2898   return retval;
2899 }
2900
2901 static dbus_bool_t
2902 bools_equal (dbus_bool_t a,
2903              dbus_bool_t b)
2904 {
2905   return a ? b : !b;
2906 }
2907
2908 static dbus_bool_t
2909 strings_equal_or_both_null (const char *a,
2910                             const char *b)
2911 {
2912   if (a == NULL || b == NULL)
2913     return a == b;
2914   else
2915     return !strcmp (a, b);
2916 }
2917
2918 static dbus_bool_t
2919 elements_equal (const Element *a,
2920                 const Element *b)
2921 {
2922   if (a->type != b->type)
2923     return FALSE;
2924
2925   if (!bools_equal (a->had_content, b->had_content))
2926     return FALSE;
2927
2928   switch (a->type)
2929     {
2930
2931     case ELEMENT_INCLUDE:
2932       if (!bools_equal (a->d.include.ignore_missing,
2933                         b->d.include.ignore_missing))
2934         return FALSE;
2935       break;
2936
2937     case ELEMENT_POLICY:
2938       if (a->d.policy.type != b->d.policy.type)
2939         return FALSE;
2940       if (a->d.policy.gid_uid_or_at_console != b->d.policy.gid_uid_or_at_console)
2941         return FALSE;
2942       break;
2943
2944     case ELEMENT_LIMIT:
2945       if (strcmp (a->d.limit.name, b->d.limit.name))
2946         return FALSE;
2947       if (a->d.limit.value != b->d.limit.value)
2948         return FALSE;
2949       break;
2950
2951     default:
2952       /* do nothing */
2953       break;
2954     }
2955
2956   return TRUE;
2957
2958 }
2959
2960 static dbus_bool_t
2961 lists_of_elements_equal (DBusList *a,
2962                          DBusList *b)
2963 {
2964   DBusList *ia;
2965   DBusList *ib;
2966
2967   ia = a;
2968   ib = b;
2969
2970   while (ia != NULL && ib != NULL)
2971     {
2972       if (elements_equal (ia->data, ib->data))
2973         return FALSE;
2974       ia = _dbus_list_get_next_link (&a, ia);
2975       ib = _dbus_list_get_next_link (&b, ib);
2976     }
2977
2978   return ia == NULL && ib == NULL;
2979 }
2980
2981 static dbus_bool_t
2982 lists_of_c_strings_equal (DBusList *a,
2983                           DBusList *b)
2984 {
2985   DBusList *ia;
2986   DBusList *ib;
2987
2988   ia = a;
2989   ib = b;
2990
2991   while (ia != NULL && ib != NULL)
2992     {
2993       if (strcmp (ia->data, ib->data))
2994         return FALSE;
2995       ia = _dbus_list_get_next_link (&a, ia);
2996       ib = _dbus_list_get_next_link (&b, ib);
2997     }
2998
2999   return ia == NULL && ib == NULL;
3000 }
3001
3002 static dbus_bool_t
3003 limits_equal (const BusLimits *a,
3004               const BusLimits *b)
3005 {
3006   return
3007     (a->max_incoming_bytes == b->max_incoming_bytes
3008      || a->max_incoming_unix_fds == b->max_incoming_unix_fds
3009      || a->max_outgoing_bytes == b->max_outgoing_bytes
3010      || a->max_outgoing_unix_fds == b->max_outgoing_unix_fds
3011      || a->max_message_size == b->max_message_size
3012      || a->max_message_unix_fds == b->max_message_unix_fds
3013      || a->activation_timeout == b->activation_timeout
3014      || a->auth_timeout == b->auth_timeout
3015      || a->max_completed_connections == b->max_completed_connections
3016      || a->max_incomplete_connections == b->max_incomplete_connections
3017      || a->max_connections_per_user == b->max_connections_per_user
3018      || a->max_pending_activations == b->max_pending_activations
3019      || a->max_services_per_connection == b->max_services_per_connection
3020      || a->max_match_rules_per_connection == b->max_match_rules_per_connection
3021      || a->max_replies_per_connection == b->max_replies_per_connection
3022      || a->reply_timeout == b->reply_timeout);
3023 }
3024
3025 static dbus_bool_t
3026 config_parsers_equal (const BusConfigParser *a,
3027                       const BusConfigParser *b)
3028 {
3029   if (!_dbus_string_equal (&a->basedir, &b->basedir))
3030     return FALSE;
3031
3032   if (!lists_of_elements_equal (a->stack, b->stack))
3033     return FALSE;
3034
3035   if (!strings_equal_or_both_null (a->user, b->user))
3036     return FALSE;
3037
3038   if (!lists_of_c_strings_equal (a->listen_on, b->listen_on))
3039     return FALSE;
3040
3041   if (!lists_of_c_strings_equal (a->mechanisms, b->mechanisms))
3042     return FALSE;
3043
3044   if (!lists_of_c_strings_equal (a->service_dirs, b->service_dirs))
3045     return FALSE;
3046
3047   /* FIXME: compare policy */
3048
3049   /* FIXME: compare service selinux ID table */
3050
3051   if (! limits_equal (&a->limits, &b->limits))
3052     return FALSE;
3053
3054   if (!strings_equal_or_both_null (a->pidfile, b->pidfile))
3055     return FALSE;
3056
3057   if (! bools_equal (a->fork, b->fork))
3058     return FALSE;
3059
3060   if (! bools_equal (a->keep_umask, b->keep_umask))
3061     return FALSE;
3062
3063   if (! bools_equal (a->is_toplevel, b->is_toplevel))
3064     return FALSE;
3065
3066   return TRUE;
3067 }
3068
3069 static dbus_bool_t
3070 all_are_equiv (const DBusString *target_directory)
3071 {
3072   DBusString filename;
3073   DBusDirIter *dir;
3074   BusConfigParser *first_parser;
3075   BusConfigParser *parser;
3076   DBusError error;
3077   dbus_bool_t equal;
3078   dbus_bool_t retval;
3079
3080   dir = NULL;
3081   first_parser = NULL;
3082   parser = NULL;
3083   retval = FALSE;
3084
3085   if (!_dbus_string_init (&filename))
3086     _dbus_assert_not_reached ("didn't allocate filename string");
3087
3088   dbus_error_init (&error);
3089   dir = _dbus_directory_open (target_directory, &error);
3090   if (dir == NULL)
3091     {
3092       _dbus_warn ("Could not open %s: %s\n",
3093                   _dbus_string_get_const_data (target_directory),
3094                   error.message);
3095       dbus_error_free (&error);
3096       goto finished;
3097     }
3098
3099   printf ("Comparing equivalent files:\n");
3100
3101  next:
3102   while (_dbus_directory_get_next_file (dir, &filename, &error))
3103     {
3104       DBusString full_path;
3105
3106       if (!_dbus_string_init (&full_path))
3107         _dbus_assert_not_reached ("couldn't init string");
3108
3109       if (!_dbus_string_copy (target_directory, 0, &full_path, 0))
3110         _dbus_assert_not_reached ("couldn't copy dir to full_path");
3111
3112       if (!_dbus_concat_dir_and_file (&full_path, &filename))
3113         _dbus_assert_not_reached ("couldn't concat file to dir");
3114
3115       if (!_dbus_string_ends_with_c_str (&full_path, ".conf"))
3116         {
3117           _dbus_verbose ("Skipping non-.conf file %s\n",
3118                          _dbus_string_get_const_data (&filename));
3119           _dbus_string_free (&full_path);
3120           goto next;
3121         }
3122
3123       printf ("    %s\n", _dbus_string_get_const_data (&filename));
3124
3125       parser = bus_config_load (&full_path, TRUE, NULL, &error);
3126
3127       if (parser == NULL)
3128         {
3129           _dbus_warn ("Could not load file %s: %s\n",
3130                       _dbus_string_get_const_data (&full_path),
3131                       error.message);
3132           _dbus_string_free (&full_path);
3133           dbus_error_free (&error);
3134           goto finished;
3135         }
3136       else if (first_parser == NULL)
3137         {
3138           _dbus_string_free (&full_path);
3139           first_parser = parser;
3140         }
3141       else
3142         {
3143           _dbus_string_free (&full_path);
3144           equal = config_parsers_equal (first_parser, parser);
3145           bus_config_parser_unref (parser);
3146           if (! equal)
3147             goto finished;
3148         }
3149     }
3150
3151   retval = TRUE;
3152
3153  finished:
3154   _dbus_string_free (&filename);
3155   if (first_parser)
3156     bus_config_parser_unref (first_parser);
3157   if (dir)
3158     _dbus_directory_close (dir);
3159
3160   return retval;
3161
3162 }
3163
3164 static dbus_bool_t
3165 process_test_equiv_subdir (const DBusString *test_base_dir,
3166                            const char       *subdir)
3167 {
3168   DBusString test_directory;
3169   DBusString filename;
3170   DBusDirIter *dir;
3171   DBusError error;
3172   dbus_bool_t equal;
3173   dbus_bool_t retval;
3174
3175   dir = NULL;
3176   retval = FALSE;
3177
3178   if (!_dbus_string_init (&test_directory))
3179     _dbus_assert_not_reached ("didn't allocate test_directory");
3180
3181   _dbus_string_init_const (&filename, subdir);
3182
3183   if (!_dbus_string_copy (test_base_dir, 0,
3184                           &test_directory, 0))
3185     _dbus_assert_not_reached ("couldn't copy test_base_dir to test_directory");
3186
3187   if (!_dbus_concat_dir_and_file (&test_directory, &filename))
3188     _dbus_assert_not_reached ("couldn't allocate full path");
3189
3190   _dbus_string_free (&filename);
3191   if (!_dbus_string_init (&filename))
3192     _dbus_assert_not_reached ("didn't allocate filename string");
3193
3194   dbus_error_init (&error);
3195   dir = _dbus_directory_open (&test_directory, &error);
3196   if (dir == NULL)
3197     {
3198       _dbus_warn ("Could not open %s: %s\n",
3199                   _dbus_string_get_const_data (&test_directory),
3200                   error.message);
3201       dbus_error_free (&error);
3202       goto finished;
3203     }
3204
3205   while (_dbus_directory_get_next_file (dir, &filename, &error))
3206     {
3207       DBusString full_path;
3208
3209       /* Skip CVS's magic directories! */
3210       if (_dbus_string_equal_c_str (&filename, "CVS"))
3211         continue;
3212
3213       if (!_dbus_string_init (&full_path))
3214         _dbus_assert_not_reached ("couldn't init string");
3215
3216       if (!_dbus_string_copy (&test_directory, 0, &full_path, 0))
3217         _dbus_assert_not_reached ("couldn't copy dir to full_path");
3218
3219       if (!_dbus_concat_dir_and_file (&full_path, &filename))
3220         _dbus_assert_not_reached ("couldn't concat file to dir");
3221
3222       equal = all_are_equiv (&full_path);
3223       _dbus_string_free (&full_path);
3224
3225       if (!equal)
3226         goto finished;
3227     }
3228
3229   retval = TRUE;
3230
3231  finished:
3232   _dbus_string_free (&test_directory);
3233   _dbus_string_free (&filename);
3234   if (dir)
3235     _dbus_directory_close (dir);
3236
3237   return retval;
3238
3239 }
3240
3241 static const char *test_session_service_dir_matches[] =
3242         {
3243 #ifdef DBUS_UNIX
3244          "/testusr/testlocal/testshare/dbus-1/services",
3245          "/testusr/testshare/dbus-1/services",
3246 #endif
3247          DBUS_DATADIR"/dbus-1/services",
3248 #ifdef DBUS_UNIX
3249          "/testhome/foo/.testlocal/testshare/dbus-1/services",
3250 #endif
3251 #ifdef DBUS_WIN
3252          NULL,
3253 #endif
3254          NULL
3255         };
3256
3257 static dbus_bool_t
3258 test_default_session_servicedirs (void)
3259 {
3260   DBusList *dirs;
3261   DBusList *link;
3262   DBusString progs;
3263   const char *common_progs;
3264   int i;
3265
3266   /* On Unix we don't actually use this variable, but it's easier to handle the
3267    * deallocation if we always allocate it, whether needed or not */
3268   if (!_dbus_string_init (&progs))
3269     _dbus_assert_not_reached ("OOM allocating progs");
3270
3271   common_progs = _dbus_getenv ("CommonProgramFiles");
3272 #ifndef DBUS_UNIX
3273   if (common_progs)
3274     {
3275       if (!_dbus_string_append (&progs, common_progs))
3276         {
3277           _dbus_string_free (&progs);
3278           return FALSE;
3279         }
3280
3281       if (!_dbus_string_append (&progs, "/dbus-1/services"))
3282         {
3283           _dbus_string_free (&progs);
3284           return FALSE;
3285         }
3286       test_session_service_dir_matches[1] = _dbus_string_get_const_data(&progs);
3287     }
3288 #endif
3289   dirs = NULL;
3290
3291   printf ("Testing retrieving the default session service directories\n");
3292   if (!_dbus_get_standard_session_servicedirs (&dirs))
3293     _dbus_assert_not_reached ("couldn't get stardard dirs");
3294
3295   /* make sure our defaults end with share/dbus-1/service */
3296   while ((link = _dbus_list_pop_first_link (&dirs)))
3297     {
3298       DBusString path;
3299
3300       printf ("    default service dir: %s\n", (char *)link->data);
3301       _dbus_string_init_const (&path, (char *)link->data);
3302       if (!_dbus_string_ends_with_c_str (&path, "dbus-1/services"))
3303         {
3304           printf ("error with default session service directories\n");
3305               dbus_free (link->data);
3306           _dbus_list_free_link (link);
3307           _dbus_string_free (&progs);
3308           return FALSE;
3309         }
3310
3311       dbus_free (link->data);
3312       _dbus_list_free_link (link);
3313     }
3314
3315 #ifdef DBUS_UNIX
3316   if (!_dbus_setenv ("XDG_DATA_HOME", "/testhome/foo/.testlocal/testshare"))
3317     _dbus_assert_not_reached ("couldn't setenv XDG_DATA_HOME");
3318
3319   if (!_dbus_setenv ("XDG_DATA_DIRS", ":/testusr/testlocal/testshare: :/testusr/testshare:"))
3320     _dbus_assert_not_reached ("couldn't setenv XDG_DATA_DIRS");
3321 #endif
3322   if (!_dbus_get_standard_session_servicedirs (&dirs))
3323     _dbus_assert_not_reached ("couldn't get stardard dirs");
3324
3325   /* make sure we read and parse the env variable correctly */
3326   i = 0;
3327   while ((link = _dbus_list_pop_first_link (&dirs)))
3328     {
3329       printf ("    test service dir: %s\n", (char *)link->data);
3330       if (test_session_service_dir_matches[i] == NULL)
3331         {
3332           printf ("more directories parsed than in match set\n");
3333           dbus_free (link->data);
3334           _dbus_list_free_link (link);
3335           _dbus_string_free (&progs);
3336           return FALSE;
3337         }
3338
3339       if (strcmp (test_session_service_dir_matches[i],
3340                   (char *)link->data) != 0)
3341         {
3342           printf ("%s directory does not match %s in the match set\n",
3343                   (char *)link->data,
3344                   test_session_service_dir_matches[i]);
3345           dbus_free (link->data);
3346           _dbus_list_free_link (link);
3347           _dbus_string_free (&progs);
3348           return FALSE;
3349         }
3350
3351       ++i;
3352
3353       dbus_free (link->data);
3354       _dbus_list_free_link (link);
3355     }
3356
3357   if (test_session_service_dir_matches[i] != NULL)
3358     {
3359       printf ("extra data %s in the match set was not matched\n",
3360               test_session_service_dir_matches[i]);
3361
3362       _dbus_string_free (&progs);
3363       return FALSE;
3364     }
3365
3366   _dbus_string_free (&progs);
3367   return TRUE;
3368 }
3369
3370 static const char *test_system_service_dir_matches[] =
3371         {
3372 #ifdef DBUS_UNIX
3373          "/testusr/testlocal/testshare/dbus-1/system-services",
3374          "/testusr/testshare/dbus-1/system-services",
3375 #endif
3376          DBUS_DATADIR"/dbus-1/system-services",
3377 #ifdef DBUS_WIN
3378          NULL,
3379 #endif
3380          NULL
3381         };
3382
3383 static dbus_bool_t
3384 test_default_system_servicedirs (void)
3385 {
3386   DBusList *dirs;
3387   DBusList *link;
3388   DBusString progs;
3389   const char *common_progs;
3390   int i;
3391
3392   /* On Unix we don't actually use this variable, but it's easier to handle the
3393    * deallocation if we always allocate it, whether needed or not */
3394   if (!_dbus_string_init (&progs))
3395     _dbus_assert_not_reached ("OOM allocating progs");
3396
3397   common_progs = _dbus_getenv ("CommonProgramFiles");
3398 #ifndef DBUS_UNIX
3399   if (common_progs)
3400     {
3401       if (!_dbus_string_append (&progs, common_progs))
3402         {
3403           _dbus_string_free (&progs);
3404           return FALSE;
3405         }
3406
3407       if (!_dbus_string_append (&progs, "/dbus-1/system-services"))
3408         {
3409           _dbus_string_free (&progs);
3410           return FALSE;
3411         }
3412       test_system_service_dir_matches[1] = _dbus_string_get_const_data(&progs);
3413     }
3414 #endif
3415   dirs = NULL;
3416
3417   printf ("Testing retrieving the default system service directories\n");
3418   if (!_dbus_get_standard_system_servicedirs (&dirs))
3419     _dbus_assert_not_reached ("couldn't get stardard dirs");
3420
3421   /* make sure our defaults end with share/dbus-1/system-service */
3422   while ((link = _dbus_list_pop_first_link (&dirs)))
3423     {
3424       DBusString path;
3425
3426       printf ("    default service dir: %s\n", (char *)link->data);
3427       _dbus_string_init_const (&path, (char *)link->data);
3428       if (!_dbus_string_ends_with_c_str (&path, "dbus-1/system-services"))
3429         {
3430           printf ("error with default system service directories\n");
3431               dbus_free (link->data);
3432           _dbus_list_free_link (link);
3433           _dbus_string_free (&progs);
3434           return FALSE;
3435         }
3436
3437       dbus_free (link->data);
3438       _dbus_list_free_link (link);
3439     }
3440
3441 #ifdef DBUS_UNIX
3442   if (!_dbus_setenv ("XDG_DATA_HOME", "/testhome/foo/.testlocal/testshare"))
3443     _dbus_assert_not_reached ("couldn't setenv XDG_DATA_HOME");
3444
3445   if (!_dbus_setenv ("XDG_DATA_DIRS", ":/testusr/testlocal/testshare: :/testusr/testshare:"))
3446     _dbus_assert_not_reached ("couldn't setenv XDG_DATA_DIRS");
3447 #endif
3448   if (!_dbus_get_standard_system_servicedirs (&dirs))
3449     _dbus_assert_not_reached ("couldn't get stardard dirs");
3450
3451   /* make sure we read and parse the env variable correctly */
3452   i = 0;
3453   while ((link = _dbus_list_pop_first_link (&dirs)))
3454     {
3455       printf ("    test service dir: %s\n", (char *)link->data);
3456       if (test_system_service_dir_matches[i] == NULL)
3457         {
3458           printf ("more directories parsed than in match set\n");
3459           dbus_free (link->data);
3460           _dbus_list_free_link (link);
3461           _dbus_string_free (&progs);
3462           return FALSE;
3463         }
3464
3465       if (strcmp (test_system_service_dir_matches[i],
3466                   (char *)link->data) != 0)
3467         {
3468           printf ("%s directory does not match %s in the match set\n",
3469                   (char *)link->data,
3470                   test_system_service_dir_matches[i]);
3471           dbus_free (link->data);
3472           _dbus_list_free_link (link);
3473           _dbus_string_free (&progs);
3474           return FALSE;
3475         }
3476
3477       ++i;
3478
3479       dbus_free (link->data);
3480       _dbus_list_free_link (link);
3481     }
3482
3483   if (test_system_service_dir_matches[i] != NULL)
3484     {
3485       printf ("extra data %s in the match set was not matched\n",
3486               test_system_service_dir_matches[i]);
3487
3488       _dbus_string_free (&progs);
3489       return FALSE;
3490     }
3491
3492   _dbus_string_free (&progs);
3493   return TRUE;
3494 }
3495
3496 dbus_bool_t
3497 bus_config_parser_test (const DBusString *test_data_dir)
3498 {
3499   if (test_data_dir == NULL ||
3500       _dbus_string_get_length (test_data_dir) == 0)
3501     {
3502       printf ("No test data\n");
3503       return TRUE;
3504     }
3505
3506   if (!test_default_session_servicedirs())
3507     return FALSE;
3508
3509 #ifdef DBUS_WIN
3510   printf("default system service dir skipped\n");
3511 #else
3512   if (!test_default_system_servicedirs())
3513     return FALSE;
3514 #endif
3515
3516   if (!process_test_valid_subdir (test_data_dir, "valid-config-files", VALID))
3517     return FALSE;
3518
3519   if (!process_test_valid_subdir (test_data_dir, "invalid-config-files", INVALID))
3520     return FALSE;
3521
3522   if (!process_test_equiv_subdir (test_data_dir, "equiv-config-files"))
3523     return FALSE;
3524
3525   return TRUE;
3526 }
3527
3528 #endif /* DBUS_BUILD_TESTS */
3529