1 /* -*- mode: C; c-file-style: "gnu" -*- */

     2 /* config-parser.c  XML-library-agnostic configuration file parser

     3  *

     4  * Copyright (C) 2003, 2004 Red Hat, Inc.

     5  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

     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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    21  *

    22  */

    23 #include "config-parser.h"

    24 #include "test.h"

    25 #include "utils.h"

    26 #include "policy.h"

    27 #include "selinux.h"

    28 #ifndef __SYMBIAN32__

    29 #include <dbus/dbus-list.h>

    30 #include <dbus/dbus-internals.h>

    31 #else

    32 #include "dbus-list.h"

    33 #include "dbus-internals.h"

    34 #endif //__SYMBIAN32__

    35 #include <string.h>

    36 

    37 typedef enum

    38 {

    39   ELEMENT_NONE,

    40   ELEMENT_BUSCONFIG,

    41   ELEMENT_INCLUDE,

    42   ELEMENT_USER,

    43   ELEMENT_LISTEN,

    44   ELEMENT_AUTH,

    45   ELEMENT_POLICY,

    46   ELEMENT_LIMIT,

    47   ELEMENT_ALLOW,

    48   ELEMENT_DENY,

    49   ELEMENT_FORK,

    50   ELEMENT_PIDFILE,

    51   ELEMENT_SERVICEDIR,

    52   ELEMENT_INCLUDEDIR,

    53   ELEMENT_TYPE,

    54   ELEMENT_SELINUX,

    55   ELEMENT_ASSOCIATE,

    56   ELEMENT_STANDARD_SESSION_SERVICEDIRS

    57 } ElementType;

    58 

    59 typedef enum

    60 {

    61   /* we ignore policies for unknown groups/users */

    62   POLICY_IGNORED,

    63 

    64   /* non-ignored */

    65   POLICY_DEFAULT,

    66   POLICY_MANDATORY,

    67   POLICY_USER,

    68   POLICY_GROUP,

    69   POLICY_CONSOLE

    70 } PolicyType;

    71 

    72 typedef struct

    73 {

    74   ElementType type;

    75 

    76   unsigned int had_content : 1;

    77 

    78   union

    79   {

    80     struct

    81     {

    82       unsigned int ignore_missing : 1;

    83       unsigned int if_selinux_enabled : 1;

    84       unsigned int selinux_root_relative : 1;

    85     } include;

    86 

    87     struct

    88     {

    89       PolicyType type;

    90       unsigned long gid_uid_or_at_console;      

    91     } policy;

    92 

    93     struct

    94     {

    95       char *name;

    96       long value;

    97     } limit;

    98     

    99   } d;

   100 

   101 } Element;

   102 

   103 /**

   104  * Parser for bus configuration file. 

   105  */

   106 struct BusConfigParser

   107 {

   108   int refcount;        /**< Reference count */

   109 

   110   DBusString basedir;  /**< Directory we resolve paths relative to */

   111   

   112   DBusList *stack;     /**< stack of Element */

   113 

   114   char *user;          /**< user to run as */

   115 

   116   char *bus_type;          /**< Message bus type */

   117   

   118   DBusList *listen_on; /**< List of addresses to listen to */

   119 

   120   DBusList *mechanisms; /**< Auth mechanisms */

   121 

   122   DBusList *service_dirs; /**< Directories to look for services in */

   123 

   124   DBusList *conf_dirs;   /**< Directories to look for policy configuration in */

   125 

   126   BusPolicy *policy;     /**< Security policy */

   127 

   128   BusLimits limits;      /**< Limits */

   129 

   130   char *pidfile;         /**< PID file */

   131 

   132   DBusList *included_files;  /**< Included files stack */

   133 

   134   DBusHashTable *service_context_table; /**< Map service names to SELinux contexts */

   135 

   136   unsigned int fork : 1; /**< TRUE to fork into daemon mode */

   137 

   138   unsigned int is_toplevel : 1; /**< FALSE if we are a sub-config-file inside another one */

   139 };

   140 

   141 static const char*

   142 element_type_to_name (ElementType type)

   143 {

   144   switch (type)

   145     {

   146     case ELEMENT_NONE:

   147       return NULL;

   148     case ELEMENT_BUSCONFIG:

   149       return "busconfig";

   150     case ELEMENT_INCLUDE:

   151       return "include";

   152     case ELEMENT_USER:

   153       return "user";

   154     case ELEMENT_LISTEN:

   155       return "listen";

   156     case ELEMENT_AUTH:

   157       return "auth";

   158     case ELEMENT_POLICY:

   159       return "policy";

   160     case ELEMENT_LIMIT:

   161       return "limit";

   162     case ELEMENT_ALLOW:

   163       return "allow";

   164     case ELEMENT_DENY:

   165       return "deny";

   166     case ELEMENT_FORK:

   167       return "fork";

   168     case ELEMENT_PIDFILE:

   169       return "pidfile";

   170     case ELEMENT_STANDARD_SESSION_SERVICEDIRS:

   171       return "standard_session_servicedirs";

   172     case ELEMENT_SERVICEDIR:

   173       return "servicedir";

   174     case ELEMENT_INCLUDEDIR:

   175       return "includedir";

   176     case ELEMENT_TYPE:

   177       return "type";

   178     case ELEMENT_SELINUX:

   179       return "selinux";

   180     case ELEMENT_ASSOCIATE:

   181       return "associate";

   182     }

   183 

   184   _dbus_assert_not_reached ("bad element type");

   185 

   186   return NULL;

   187 }

   188 

   189 static Element*

   190 push_element (BusConfigParser *parser,

   191               ElementType      type)

   192 {

   193   Element *e;

   194 

   195   _dbus_assert (type != ELEMENT_NONE);

   196   

   197   e = dbus_new0 (Element, 1);

   198   if (e == NULL)

   199     return NULL;

   200 

   201   if (!_dbus_list_append (&parser->stack, e))

   202     {

   203       dbus_free (e);

   204       return NULL;

   205     }

   206   

   207   e->type = type;

   208 

   209   return e;

   210 }

   211 

   212 static void

   213 element_free (Element *e)

   214 {

   215   if (e->type == ELEMENT_LIMIT)

   216     dbus_free (e->d.limit.name);

   217   

   218   dbus_free (e);

   219 }

   220 

   221 static void

   222 pop_element (BusConfigParser *parser)

   223 {

   224   Element *e;

   225 

   226   e = _dbus_list_pop_last (&parser->stack);

   227   

   228   element_free (e);

   229 }

   230 

   231 static Element*

   232 peek_element (BusConfigParser *parser)

   233 {

   234   Element *e;

   235 

   236   e = _dbus_list_get_last (&parser->stack);

   237 

   238   return e;

   239 }

   240 

   241 static ElementType

   242 top_element_type (BusConfigParser *parser)

   243 {

   244   Element *e;

   245 

   246   e = _dbus_list_get_last (&parser->stack);

   247 

   248   if (e)

   249     return e->type;

   250   else

   251     return ELEMENT_NONE;

   252 }

   253 

   254 static dbus_bool_t

   255 merge_service_context_hash (DBusHashTable *dest,

   256 			    DBusHashTable *from)

   257 {

   258   DBusHashIter iter;

   259   char *service_copy;

   260   char *context_copy;

   261 

   262   service_copy = NULL;

   263   context_copy = NULL;

   264 

   265   _dbus_hash_iter_init (from, &iter);

   266   while (_dbus_hash_iter_next (&iter))

   267     {

   268       const char *service = _dbus_hash_iter_get_string_key (&iter);

   269       const char *context = _dbus_hash_iter_get_value (&iter);

   270 

   271       service_copy = _dbus_strdup (service);

   272       if (service_copy == NULL)

   273         goto fail;

   274       context_copy = _dbus_strdup (context);

   275       if (context_copy == NULL)

   276         goto fail; 

   277       

   278       if (!_dbus_hash_table_insert_string (dest, service_copy, context_copy))

   279         goto fail;

   280 

   281       service_copy = NULL;

   282       context_copy = NULL;    

   283     }

   284 

   285   return TRUE;

   286 

   287  fail:

   288   if (service_copy)

   289     dbus_free (service_copy);

   290 

   291   if (context_copy)

   292     dbus_free (context_copy);

   293 

   294   return FALSE;

   295 }

   296 

   297 static dbus_bool_t

   298 service_dirs_find_dir (DBusList **service_dirs,

   299                        const char *dir)

   300 {

   301   DBusList *link;

   302 

   303   _dbus_assert (dir != NULL);

   304 

   305   for (link = *service_dirs; link; link = _dbus_list_get_next_link(service_dirs, link))

   306     {

   307       const char *link_dir;

   308       

   309       link_dir = (const char *)link->data;

   310       if (strcmp (dir, link_dir) == 0)

   311         return TRUE;

   312     }

   313 

   314   return FALSE;

   315 }

   316 

   317 static dbus_bool_t

   318 service_dirs_append_unique_or_free (DBusList **service_dirs,

   319                                     char *dir)

   320 {

   321   if (!service_dirs_find_dir (service_dirs, dir))

   322     return _dbus_list_append (service_dirs, dir);  

   323 

   324   dbus_free (dir);

   325   return TRUE;

   326 }

   327 

   328 static void 

   329 service_dirs_append_link_unique_or_free (DBusList **service_dirs,

   330                                          DBusList *dir_link)

   331 {

   332   if (!service_dirs_find_dir (service_dirs, dir_link->data))

   333     {

   334       _dbus_list_append_link (service_dirs, dir_link);

   335     }

   336   else

   337     {

   338       dbus_free (dir_link->data);

   339       _dbus_list_free_link (dir_link);

   340     }

   341 }

   342 

   343 static dbus_bool_t

   344 merge_included (BusConfigParser *parser,

   345                 BusConfigParser *included,

   346                 DBusError       *error)

   347 {

   348   DBusList *link;

   349 

   350   if (!bus_policy_merge (parser->policy,

   351                          included->policy))

   352     {

   353       BUS_SET_OOM (error);

   354       return FALSE;

   355     }

   356 

   357   if (!merge_service_context_hash (parser->service_context_table,

   358 				   included->service_context_table))

   359     {

   360       BUS_SET_OOM (error);

   361       return FALSE;

   362     }

   363   

   364   if (included->user != NULL)

   365     {

   366       dbus_free (parser->user);

   367       parser->user = included->user;

   368       included->user = NULL;

   369     }

   370 

   371   if (included->bus_type != NULL)

   372     {

   373       dbus_free (parser->bus_type);

   374       parser->bus_type = included->bus_type;

   375       included->bus_type = NULL;

   376     }

   377   

   378   if (included->fork)

   379     parser->fork = TRUE;

   380 

   381   if (included->pidfile != NULL)

   382     {

   383       dbus_free (parser->pidfile);

   384       parser->pidfile = included->pidfile;

   385       included->pidfile = NULL;

   386     }

   387   

   388   while ((link = _dbus_list_pop_first_link (&included->listen_on)))

   389     _dbus_list_append_link (&parser->listen_on, link);

   390 

   391   while ((link = _dbus_list_pop_first_link (&included->mechanisms)))

   392     _dbus_list_append_link (&parser->mechanisms, link);

   393 

   394   while ((link = _dbus_list_pop_first_link (&included->service_dirs)))

   395     service_dirs_append_link_unique_or_free (&parser->service_dirs, link);

   396 

   397   while ((link = _dbus_list_pop_first_link (&included->conf_dirs)))

   398     _dbus_list_append_link (&parser->conf_dirs, link);

   399   

   400   return TRUE;

   401 }

   402 

   403 static dbus_bool_t

   404 seen_include (BusConfigParser  *parser,

   405 	      const DBusString *file)

   406 {

   407   DBusList *iter;

   408 

   409   iter = parser->included_files;

   410   while (iter != NULL)

   411     {

   412       if (! strcmp (_dbus_string_get_const_data (file), iter->data))

   413 	return TRUE;

   414 

   415       iter = _dbus_list_get_next_link (&parser->included_files, iter);

   416     }

   417 

   418   return FALSE;

   419 }

   420 

   421 BusConfigParser*

   422 bus_config_parser_new (const DBusString      *basedir,

   423                        dbus_bool_t            is_toplevel,

   424                        const BusConfigParser *parent)

   425 {

   426   BusConfigParser *parser;

   427 

   428   parser = dbus_new0 (BusConfigParser, 1);

   429   if (parser == NULL)

   430     return NULL;

   431 

   432   parser->is_toplevel = !!is_toplevel;

   433   

   434   if (!_dbus_string_init (&parser->basedir))

   435     {

   436       dbus_free (parser);

   437       return NULL;

   438     }

   439 

   440   if (((parser->policy = bus_policy_new ()) == NULL) ||

   441       !_dbus_string_copy (basedir, 0, &parser->basedir, 0) ||

   442       ((parser->service_context_table = _dbus_hash_table_new (DBUS_HASH_STRING,

   443 							      dbus_free,

   444 							      dbus_free)) == NULL))

   445     {

   446       if (parser->policy)

   447         bus_policy_unref (parser->policy);

   448       

   449       _dbus_string_free (&parser->basedir);

   450 

   451       dbus_free (parser);

   452       return NULL;

   453     }

   454 

   455   if (parent != NULL)

   456     {

   457       /* Initialize the parser's limits from the parent. */

   458       parser->limits = parent->limits;

   459 

   460       /* Use the parent's list of included_files to avoid

   461 	 circular inclusions. */

   462       parser->included_files = parent->included_files;

   463     }

   464   else

   465     {

   466 

   467       /* Make up some numbers! woot! */

   468       parser->limits.max_incoming_bytes = _DBUS_ONE_MEGABYTE * 63;

   469       parser->limits.max_outgoing_bytes = _DBUS_ONE_MEGABYTE * 63;

   470       parser->limits.max_message_size = _DBUS_ONE_MEGABYTE * 32;

   471       

   472       /* Making this long means the user has to wait longer for an error

   473        * message if something screws up, but making it too short means

   474        * they might see a false failure.

   475        */

   476 #ifdef __SYMBIAN32__

   477       parser->limits.activation_timeout = 250000; /*  changed to 250 seconds */

   478 #else

   479       parser->limits.activation_timeout = 25000; 

   480 #endif

   481       /* Making this long risks making a DOS attack easier, but too short

   482        * and legitimate auth will fail.  If interactive auth (ask user for

   483        * password) is allowed, then potentially it has to be quite long.

   484        */

   485       parser->limits.auth_timeout = 300000; /* 30 seconds bsr changed to 300 sec*/

   486       

   487       parser->limits.max_incomplete_connections = 32;

   488       parser->limits.max_connections_per_user = 128;

   489       

   490       /* Note that max_completed_connections / max_connections_per_user

   491        * is the number of users that would have to work together to

   492        * DOS all the other users.

   493        */

   494       parser->limits.max_completed_connections = 1024;

   495       

   496       parser->limits.max_pending_activations = 256;

   497       parser->limits.max_services_per_connection = 256;

   498       

   499       parser->limits.max_match_rules_per_connection = 512;

   500       

   501       parser->limits.reply_timeout = 5 * 60 * 1000; /* 5 minutes */

   502       parser->limits.max_replies_per_connection = 32;

   503       

   504       

   505       /*

   506       parser->limits.max_incoming_bytes = 1024 * 1024 * 63;

   507       parser->limits.max_outgoing_bytes = 1024 * 1024 * 63;

   508       parser->limits.max_message_size = 1024 * 1024 * 32;

   509       parser->limits.activation_timeout = 250000;

   510       parser->limits.auth_timeout = 300000;

   511       parser->limits.max_incomplete_connections = 32;

   512       parser->limits.max_connections_per_user = 128;

   513       parser->limits.max_completed_connections = 1024;

   514       parser->limits.max_pending_activations = 256;

   515       parser->limits.max_services_per_connection = 256;

   516       parser->limits.max_match_rules_per_connection = 512;

   517       parser->limits.reply_timeout = 5 * 60 * 1000;

   518       parser->limits.max_replies_per_connection = 32;

   519       */

   520       

   521       

   522       

   523     }

   524       

   525   parser->refcount = 1;

   526       

   527   return parser;

   528 }

   529 

   530 BusConfigParser *

   531 bus_config_parser_ref (BusConfigParser *parser)

   532 {

   533   _dbus_assert (parser->refcount > 0);

   534 

   535   parser->refcount += 1;

   536 

   537   return parser;

   538 }

   539 

   540 void

   541 bus_config_parser_unref (BusConfigParser *parser)

   542 {

   543   _dbus_assert (parser->refcount > 0);

   544 

   545   parser->refcount -= 1;

   546 

   547   if (parser->refcount == 0)

   548     {

   549       while (parser->stack != NULL)

   550         pop_element (parser);

   551 

   552       dbus_free (parser->user);

   553       dbus_free (parser->bus_type);

   554       dbus_free (parser->pidfile);

   555       

   556       _dbus_list_foreach (&parser->listen_on,

   557                           (DBusForeachFunction) dbus_free,

   558                           NULL);

   559 

   560       _dbus_list_clear (&parser->listen_on);

   561 

   562       _dbus_list_foreach (&parser->service_dirs,

   563                           (DBusForeachFunction) dbus_free,

   564                           NULL);

   565 

   566       _dbus_list_clear (&parser->service_dirs);

   567 

   568       _dbus_list_foreach (&parser->conf_dirs,

   569                           (DBusForeachFunction) dbus_free,

   570                           NULL);

   571 

   572       _dbus_list_clear (&parser->conf_dirs);

   573 

   574       _dbus_list_foreach (&parser->mechanisms,

   575                           (DBusForeachFunction) dbus_free,

   576                           NULL);

   577 

   578       _dbus_list_clear (&parser->mechanisms);

   579       

   580       _dbus_string_free (&parser->basedir);

   581 

   582       if (parser->policy)

   583         bus_policy_unref (parser->policy);

   584 

   585       if (parser->service_context_table)

   586         _dbus_hash_table_unref (parser->service_context_table);

   587       

   588       dbus_free (parser);

   589     }

   590 }

   591 

   592 dbus_bool_t

   593 bus_config_parser_check_doctype (BusConfigParser   *parser,

   594                                  const char        *doctype,

   595                                  DBusError         *error)

   596 {

   597   _DBUS_ASSERT_ERROR_IS_CLEAR (error);

   598 

   599   if (strcmp (doctype, "busconfig") != 0)

   600     {

   601       dbus_set_error (error,

   602                       DBUS_ERROR_FAILED,

   603                       "Configuration file has the wrong document type %s",

   604                       doctype);

   605       return FALSE;

   606     }

   607   else

   608     return TRUE;

   609 }

   610 

   611 typedef struct

   612 {

   613   const char  *name;

   614   const char **retloc;

   615 } LocateAttr;

   616 

   617 static dbus_bool_t

   618 locate_attributes (BusConfigParser  *parser,

   619                    const char       *element_name,

   620                    const char      **attribute_names,

   621                    const char      **attribute_values,

   622                    DBusError        *error,

   623                    const char       *first_attribute_name,

   624                    const char      **first_attribute_retloc,

   625                    ...)

   626 {

   627   va_list args;

   628   const char *name;

   629   const char **retloc;

   630   int n_attrs;

   631 #define MAX_ATTRS 24

   632   LocateAttr attrs[MAX_ATTRS];

   633   dbus_bool_t retval;

   634   int i;

   635 

   636   _dbus_assert (first_attribute_name != NULL);

   637   _dbus_assert (first_attribute_retloc != NULL);

   638 

   639   retval = TRUE;

   640 

   641   n_attrs = 1;

   642   attrs[0].name = first_attribute_name;

   643   attrs[0].retloc = first_attribute_retloc;

   644   *first_attribute_retloc = NULL;

   645 

   646   va_start (args, first_attribute_retloc);

   647 

   648   name = va_arg (args, const char*);

   649   retloc = va_arg (args, const char**);

   650 

   651   while (name != NULL)

   652     {

   653       _dbus_assert (retloc != NULL);

   654       _dbus_assert (n_attrs < MAX_ATTRS);

   655 

   656       attrs[n_attrs].name = name;

   657       attrs[n_attrs].retloc = retloc;

   658       n_attrs += 1;

   659       *retloc = NULL;

   660 

   661       name = va_arg (args, const char*);

   662       retloc = va_arg (args, const char**);

   663     }

   664 

   665   va_end (args);

   666 

   667   if (!retval)

   668     return retval;

   669 

   670   i = 0;

   671   while (attribute_names[i])

   672     {

   673       int j;

   674       dbus_bool_t found;

   675       

   676       found = FALSE;

   677       j = 0;

   678       while (j < n_attrs)

   679         {

   680           if (strcmp (attrs[j].name, attribute_names[i]) == 0)

   681             {

   682               retloc = attrs[j].retloc;

   683 

   684               if (*retloc != NULL)

   685                 {

   686                   dbus_set_error (error, DBUS_ERROR_FAILED,

   687                                   "Attribute \"%s\" repeated twice on the same <%s> element",

   688                                   attrs[j].name, element_name);

   689                   retval = FALSE;

   690                   goto out;

   691                 }

   692 

   693               *retloc = attribute_values[i];

   694               found = TRUE;

   695             }

   696 

   697           ++j;

   698         }

   699 

   700       if (!found)

   701         {

   702           dbus_set_error (error, DBUS_ERROR_FAILED,

   703                           "Attribute \"%s\" is invalid on <%s> element in this context",

   704                           attribute_names[i], element_name);

   705           retval = FALSE;

   706           goto out;

   707         }

   708 

   709       ++i;

   710     }

   711 

   712  out:

   713   return retval;

   714 }

   715 

   716 static dbus_bool_t

   717 check_no_attributes (BusConfigParser  *parser,

   718                      const char       *element_name,

   719                      const char      **attribute_names,

   720                      const char      **attribute_values,

   721                      DBusError        *error)

   722 {

   723   if (attribute_names[0] != NULL)

   724     {

   725       dbus_set_error (error, DBUS_ERROR_FAILED,

   726                       "Attribute \"%s\" is invalid on <%s> element in this context",

   727                       attribute_names[0], element_name);

   728       return FALSE;

   729     }

   730 

   731   return TRUE;

   732 }

   733 

   734 static dbus_bool_t

   735 start_busconfig_child (BusConfigParser   *parser,

   736                        const char        *element_name,

   737                        const char       **attribute_names,

   738                        const char       **attribute_values,

   739                        DBusError         *error)

   740 {

   741   if (strcmp (element_name, "user") == 0)

   742     {

   743       if (!check_no_attributes (parser, "user", attribute_names, attribute_values, error))

   744         return FALSE;

   745 

   746       if (push_element (parser, ELEMENT_USER) == NULL)

   747         {

   748           BUS_SET_OOM (error);

   749           return FALSE;

   750         }

   751 

   752       return TRUE;

   753     }

   754   else if (strcmp (element_name, "type") == 0)

   755     {

   756       if (!check_no_attributes (parser, "type", attribute_names, attribute_values, error))

   757         return FALSE;

   758 

   759       if (push_element (parser, ELEMENT_TYPE) == NULL)

   760         {

   761           BUS_SET_OOM (error);

   762           return FALSE;

   763         }

   764 

   765       return TRUE;

   766     }

   767   else if (strcmp (element_name, "fork") == 0)

   768     {

   769       if (!check_no_attributes (parser, "fork", attribute_names, attribute_values, error))

   770         return FALSE;

   771 

   772       if (push_element (parser, ELEMENT_FORK) == NULL)

   773         {

   774           BUS_SET_OOM (error);

   775           return FALSE;

   776         }

   777 

   778       parser->fork = TRUE;

   779       

   780       return TRUE;

   781     }

   782   else if (strcmp (element_name, "pidfile") == 0)

   783     {

   784       if (!check_no_attributes (parser, "pidfile", attribute_names, attribute_values, error))

   785         return FALSE;

   786 

   787       if (push_element (parser, ELEMENT_PIDFILE) == NULL)

   788         {

   789           BUS_SET_OOM (error);

   790           return FALSE;

   791         }

   792 

   793       return TRUE;

   794     }

   795   else if (strcmp (element_name, "listen") == 0)

   796     {

   797       if (!check_no_attributes (parser, "listen", attribute_names, attribute_values, error))

   798         return FALSE;

   799 

   800       if (push_element (parser, ELEMENT_LISTEN) == NULL)

   801         {

   802           BUS_SET_OOM (error);

   803           return FALSE;

   804         }

   805 

   806       return TRUE;

   807     }

   808   else if (strcmp (element_name, "auth") == 0)

   809     {

   810       if (!check_no_attributes (parser, "auth", attribute_names, attribute_values, error))

   811         return FALSE;

   812 

   813       if (push_element (parser, ELEMENT_AUTH) == NULL)

   814         {

   815           BUS_SET_OOM (error);

   816           return FALSE;

   817         }

   818       

   819       return TRUE;

   820     }

   821   else if (strcmp (element_name, "includedir") == 0)

   822     {

   823       if (!check_no_attributes (parser, "includedir", attribute_names, attribute_values, error))

   824         return FALSE;

   825 

   826       if (push_element (parser, ELEMENT_INCLUDEDIR) == NULL)

   827         {

   828           BUS_SET_OOM (error);

   829           return FALSE;

   830         }

   831 

   832       return TRUE;

   833     }

   834   else if (strcmp (element_name, "standard_session_servicedirs") == 0)

   835     {

   836       DBusList *link;

   837       DBusList *dirs;

   838       dirs = NULL;

   839 

   840       if (!check_no_attributes (parser, "standard_session_servicedirs", attribute_names, attribute_values, error))

   841         return FALSE;

   842 

   843       if (push_element (parser, ELEMENT_STANDARD_SESSION_SERVICEDIRS) == NULL)

   844         {

   845           BUS_SET_OOM (error);

   846           return FALSE;

   847         }

   848 

   849       if (!_dbus_get_standard_session_servicedirs (&dirs))

   850         {

   851           BUS_SET_OOM (error);

   852           return FALSE;

   853         }

   854 

   855         while ((link = _dbus_list_pop_first_link (&dirs)))

   856           service_dirs_append_link_unique_or_free (&parser->service_dirs, link);

   857 

   858       return TRUE;

   859     }

   860   else if (strcmp (element_name, "servicedir") == 0)

   861     {

   862       if (!check_no_attributes (parser, "servicedir", attribute_names, attribute_values, error))

   863         return FALSE;

   864 

   865       if (push_element (parser, ELEMENT_SERVICEDIR) == NULL)

   866         {

   867           BUS_SET_OOM (error);

   868           return FALSE;

   869         }

   870 

   871       return TRUE;

   872     }

   873   else if (strcmp (element_name, "include") == 0)

   874     {

   875       Element *e;

   876       const char *if_selinux_enabled;

   877       const char *ignore_missing;

   878       const char *selinux_root_relative;

   879 

   880       if ((e = push_element (parser, ELEMENT_INCLUDE)) == NULL)

   881         {

   882           BUS_SET_OOM (error);

   883           return FALSE;

   884         }

   885 

   886       e->d.include.ignore_missing = FALSE;

   887       e->d.include.if_selinux_enabled = FALSE;

   888       e->d.include.selinux_root_relative = FALSE;

   889 

   890       if (!locate_attributes (parser, "include",

   891                               attribute_names,

   892                               attribute_values,

   893                               error,

   894                               "ignore_missing", &ignore_missing,

   895                               "if_selinux_enabled", &if_selinux_enabled,

   896                               "selinux_root_relative", &selinux_root_relative,

   897                               NULL))

   898         return FALSE;

   899 

   900       if (ignore_missing != NULL)

   901         {

   902           if (strcmp (ignore_missing, "yes") == 0)

   903             e->d.include.ignore_missing = TRUE;

   904           else if (strcmp (ignore_missing, "no") == 0)

   905             e->d.include.ignore_missing = FALSE;

   906           else

   907             {

   908               dbus_set_error (error, DBUS_ERROR_FAILED,

   909                               "ignore_missing attribute must have value \"yes\" or \"no\"");

   910               return FALSE;

   911             }

   912         }

   913 

   914       if (if_selinux_enabled != NULL)

   915         {

   916           if (strcmp (if_selinux_enabled, "yes") == 0)

   917             e->d.include.if_selinux_enabled = TRUE;

   918           else if (strcmp (if_selinux_enabled, "no") == 0)

   919             e->d.include.if_selinux_enabled = FALSE;

   920           else

   921             {

   922               dbus_set_error (error, DBUS_ERROR_FAILED,

   923                               "if_selinux_enabled attribute must have value"

   924                               " \"yes\" or \"no\"");

   925               return FALSE;

   926 	    }

   927         }

   928       

   929       if (selinux_root_relative != NULL)

   930         {

   931           if (strcmp (selinux_root_relative, "yes") == 0)

   932             e->d.include.selinux_root_relative = TRUE;

   933           else if (strcmp (selinux_root_relative, "no") == 0)

   934             e->d.include.selinux_root_relative = FALSE;

   935           else

   936             {

   937               dbus_set_error (error, DBUS_ERROR_FAILED,

   938                               "selinux_root_relative attribute must have value"

   939                               " \"yes\" or \"no\"");

   940               return FALSE;

   941 	    }

   942         }

   943 

   944       return TRUE;

   945     }

   946   else if (strcmp (element_name, "policy") == 0)

   947     {

   948       Element *e;

   949       const char *context;

   950       const char *user;

   951       const char *group;

   952       const char *at_console;

   953 

   954       if ((e = push_element (parser, ELEMENT_POLICY)) == NULL)

   955         {

   956           BUS_SET_OOM (error);

   957           return FALSE;

   958         }

   959 

   960       e->d.policy.type = POLICY_IGNORED;

   961       

   962       if (!locate_attributes (parser, "policy",

   963                               attribute_names,

   964                               attribute_values,

   965                               error,

   966                               "context", &context,

   967                               "user", &user,

   968                               "group", &group,

   969                               "at_console", &at_console,

   970                               NULL))

   971         return FALSE;

   972 

   973       if (((context && user) ||

   974            (context && group) ||

   975            (context && at_console)) ||

   976            ((user && group) ||

   977            (user && at_console)) ||

   978            (group && at_console) ||

   979           !(context || user || group || at_console))

   980         {

   981           dbus_set_error (error, DBUS_ERROR_FAILED,

   982                           "<policy> element must have exactly one of (context|user|group|at_console) attributes");

   983           return FALSE;

   984         }

   985 

   986       if (context != NULL)

   987         {

   988           if (strcmp (context, "default") == 0)

   989             {

   990               e->d.policy.type = POLICY_DEFAULT;

   991             }

   992           else if (strcmp (context, "mandatory") == 0)

   993             {

   994               e->d.policy.type = POLICY_MANDATORY;

   995             }

   996           else

   997             {

   998               dbus_set_error (error, DBUS_ERROR_FAILED,

   999                               "context attribute on <policy> must have the value \"default\" or \"mandatory\", not \"%s\"",

  1000                               context);

  1001               return FALSE;

  1002             }

  1003         }

  1004       else if (user != NULL)

  1005         {

  1006           DBusString username;

  1007           _dbus_string_init_const (&username, user);

  1008 

  1009           if (_dbus_get_user_id (&username,

  1010                                  &e->d.policy.gid_uid_or_at_console))

  1011             e->d.policy.type = POLICY_USER;

  1012           else

  1013             _dbus_warn ("Unknown username \"%s\" in message bus configuration file\n",

  1014                         user);

  1015         }

  1016       else if (group != NULL)

  1017         {

  1018           DBusString group_name;

  1019           _dbus_string_init_const (&group_name, group);

  1020 

  1021           if (_dbus_get_group_id (&group_name,

  1022                                   &e->d.policy.gid_uid_or_at_console))

  1023             e->d.policy.type = POLICY_GROUP;

  1024           else

  1025             _dbus_warn ("Unknown group \"%s\" in message bus configuration file\n",

  1026                         group);          

  1027         }

  1028       else if (at_console != NULL)

  1029         {

  1030            dbus_bool_t t;

  1031            t = (strcmp (at_console, "true") == 0);

  1032            if (t || strcmp (at_console, "false") == 0)

  1033              {

  1034                e->d.policy.gid_uid_or_at_console = t; 

  1035                e->d.policy.type = POLICY_CONSOLE;

  1036              }  

  1037            else

  1038              {

  1039                dbus_set_error (error, DBUS_ERROR_FAILED,

  1040                               "Unknown value \"%s\" for at_console in message bus configuration file",

  1041                               at_console);

  1042 

  1043                return FALSE;

  1044              }

  1045         }

  1046       else

  1047         {

  1048           _dbus_assert_not_reached ("all <policy> attributes null and we didn't set error");

  1049         }

  1050       

  1051       return TRUE;

  1052     }

  1053   else if (strcmp (element_name, "limit") == 0)

  1054     {

  1055       Element *e;

  1056       const char *name;

  1057 

  1058       if ((e = push_element (parser, ELEMENT_LIMIT)) == NULL)

  1059         {

  1060           BUS_SET_OOM (error);

  1061           return FALSE;

  1062         }

  1063       

  1064       if (!locate_attributes (parser, "limit",

  1065                               attribute_names,

  1066                               attribute_values,

  1067                               error,

  1068                               "name", &name,

  1069                               NULL))

  1070         return FALSE;

  1071 

  1072       if (name == NULL)

  1073         {

  1074           dbus_set_error (error, DBUS_ERROR_FAILED,

  1075                           "<limit> element must have a \"name\" attribute");

  1076           return FALSE;

  1077         }

  1078 

  1079       e->d.limit.name = _dbus_strdup (name);

  1080       if (e->d.limit.name == NULL)

  1081         {

  1082           BUS_SET_OOM (error);

  1083           return FALSE;

  1084         }

  1085 

  1086       return TRUE;

  1087     }

  1088   else if (strcmp (element_name, "selinux") == 0)

  1089     {

  1090       if (!check_no_attributes (parser, "selinux", attribute_names, attribute_values, error))

  1091         return FALSE;

  1092 

  1093       if (push_element (parser, ELEMENT_SELINUX) == NULL)

  1094         {

  1095           BUS_SET_OOM (error);

  1096           return FALSE;

  1097         }

  1098 

  1099       return TRUE;

  1100     }

  1101   else

  1102     {

  1103       dbus_set_error (error, DBUS_ERROR_FAILED,

  1104                       "Element <%s> not allowed inside <%s> in configuration file",

  1105                       element_name, "busconfig");

  1106       return FALSE;

  1107     }

  1108 }

  1109 

  1110 static dbus_bool_t

  1111 append_rule_from_element (BusConfigParser   *parser,

  1112                           const char        *element_name,

  1113                           const char       **attribute_names,

  1114                           const char       **attribute_values,

  1115                           dbus_bool_t        allow,

  1116                           DBusError         *error)

  1117 {

  1118   const char *send_interface;

  1119   const char *send_member;

  1120   const char *send_error;

  1121   const char *send_destination;

  1122   const char *send_path;

  1123   const char *send_type;

  1124   const char *receive_interface;

  1125   const char *receive_member;

  1126   const char *receive_error;

  1127   const char *receive_sender;

  1128   const char *receive_path;

  1129   const char *receive_type;

  1130   const char *eavesdrop;

  1131   const char *send_requested_reply;

  1132   const char *receive_requested_reply;

  1133   const char *own;

  1134   const char *user;

  1135   const char *group;