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

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

 *

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

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

 * Licensed under the Academic Free License version 2.1

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 */

#include "config-parser.h"

#include "test.h"

#include "utils.h"

#include "policy.h"

#include "selinux.h"

#ifndef __SYMBIAN32__

#include <dbus/dbus-list.h>

#include <dbus/dbus-internals.h>

#else

#include "dbus-list.h"

#include "dbus-internals.h"

#endif //__SYMBIAN32__

#include <string.h>

typedef enum

{

  ELEMENT_NONE,

  ELEMENT_BUSCONFIG,

  ELEMENT_INCLUDE,

  ELEMENT_USER,

  ELEMENT_LISTEN,

  ELEMENT_AUTH,

  ELEMENT_POLICY,

  ELEMENT_LIMIT,

  ELEMENT_ALLOW,

  ELEMENT_DENY,

  ELEMENT_FORK,

  ELEMENT_PIDFILE,

  ELEMENT_SERVICEDIR,

  ELEMENT_INCLUDEDIR,

  ELEMENT_TYPE,

  ELEMENT_SELINUX,

  ELEMENT_ASSOCIATE,

  ELEMENT_STANDARD_SESSION_SERVICEDIRS

} ElementType;

typedef enum

{

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

  POLICY_IGNORED,

  /* non-ignored */

  POLICY_DEFAULT,

  POLICY_MANDATORY,

  POLICY_USER,

  POLICY_GROUP,

  POLICY_CONSOLE

} PolicyType;

typedef struct

{

  ElementType type;

  unsigned int had_content : 1;

  union

  {

    struct

    {

      unsigned int ignore_missing : 1;

      unsigned int if_selinux_enabled : 1;

      unsigned int selinux_root_relative : 1;

    } include;

    struct

    {

      PolicyType type;

      unsigned long gid_uid_or_at_console;      

    } policy;

    struct

    {

      char *name;

      long value;

    } limit;

  } d;

} Element;

/**

 * Parser for bus configuration file. 

 */

struct BusConfigParser

{

  int refcount;        /**< Reference count */

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

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

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

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

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

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

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

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

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

  BusLimits limits;      /**< Limits */

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

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

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

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

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

};

static const char*

element_type_to_name (ElementType type)

{

  switch (type)

    {

    case ELEMENT_NONE:

      return NULL;

    case ELEMENT_BUSCONFIG:

      return "busconfig";

    case ELEMENT_INCLUDE:

      return "include";

    case ELEMENT_USER:

      return "user";

    case ELEMENT_LISTEN:

      return "listen";

    case ELEMENT_AUTH:

      return "auth";

    case ELEMENT_POLICY:

      return "policy";

    case ELEMENT_LIMIT:

      return "limit";

    case ELEMENT_ALLOW:

      return "allow";

    case ELEMENT_DENY:

      return "deny";

    case ELEMENT_FORK:

      return "fork";

    case ELEMENT_PIDFILE:

      return "pidfile";

    case ELEMENT_STANDARD_SESSION_SERVICEDIRS:

      return "standard_session_servicedirs";

    case ELEMENT_SERVICEDIR:

      return "servicedir";

    case ELEMENT_INCLUDEDIR:

      return "includedir";

    case ELEMENT_TYPE:

      return "type";

    case ELEMENT_SELINUX:

      return "selinux";

    case ELEMENT_ASSOCIATE:

      return "associate";

    }

  _dbus_assert_not_reached ("bad element type");

  return NULL;

}

static Element*

push_element (BusConfigParser *parser,

              ElementType      type)

{

  Element *e;

  _dbus_assert (type != ELEMENT_NONE);

  e = dbus_new0 (Element, 1);

  if (e == NULL)

    return NULL;

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

    {

      dbus_free (e);

      return NULL;

    }

  e->type = type;

  return e;

}

static void

element_free (Element *e)

{

  if (e->type == ELEMENT_LIMIT)

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

  dbus_free (e);

}

static void

pop_element (BusConfigParser *parser)

{

  Element *e;

  e = _dbus_list_pop_last (&parser->stack);

  element_free (e);

}

static Element*

peek_element (BusConfigParser *parser)

{

  Element *e;

  e = _dbus_list_get_last (&parser->stack);

  return e;

}

static ElementType

top_element_type (BusConfigParser *parser)

{

  Element *e;

  e = _dbus_list_get_last (&parser->stack);

  if (e)

    return e->type;

  else

    return ELEMENT_NONE;

}

static dbus_bool_t

merge_service_context_hash (DBusHashTable *dest,

			    DBusHashTable *from)

{

  DBusHashIter iter;

  char *service_copy;

  char *context_copy;

  service_copy = NULL;

  context_copy = NULL;

  _dbus_hash_iter_init (from, &iter);

  while (_dbus_hash_iter_next (&iter))

    {

      const char *service = _dbus_hash_iter_get_string_key (&iter);

      const char *context = _dbus_hash_iter_get_value (&iter);

      service_copy = _dbus_strdup (service);

      if (service_copy == NULL)

        goto fail;

      context_copy = _dbus_strdup (context);

      if (context_copy == NULL)

        goto fail; 

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

        goto fail;

      service_copy = NULL;

      context_copy = NULL;    

    }

  return TRUE;

 fail:

  if (service_copy)

    dbus_free (service_copy);

  if (context_copy)

    dbus_free (context_copy);

  return FALSE;

}

static dbus_bool_t

service_dirs_find_dir (DBusList **service_dirs,

                       const char *dir)

{

  DBusList *link;

  _dbus_assert (dir != NULL);

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

    {

      const char *link_dir;

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

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

        return TRUE;

    }

  return FALSE;

}

static dbus_bool_t

service_dirs_append_unique_or_free (DBusList **service_dirs,

                                    char *dir)

{

  if (!service_dirs_find_dir (service_dirs, dir))

    return _dbus_list_append (service_dirs, dir);  

  dbus_free (dir);

  return TRUE;

}

static void 

service_dirs_append_link_unique_or_free (DBusList **service_dirs,

                                         DBusList *dir_link)

{

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

    {

      _dbus_list_append_link (service_dirs, dir_link);

    }

  else

    {

      dbus_free (dir_link->data);

      _dbus_list_free_link (dir_link);

    }

}

static dbus_bool_t

merge_included (BusConfigParser *parser,

                BusConfigParser *included,

                DBusError       *error)

{

  DBusList *link;

  if (!bus_policy_merge (parser->policy,

                         included->policy))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!merge_service_context_hash (parser->service_context_table,

				   included->service_context_table))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (included->user != NULL)

    {

      dbus_free (parser->user);

      parser->user = included->user;

      included->user = NULL;

    }

  if (included->bus_type != NULL)

    {

      dbus_free (parser->bus_type);

      parser->bus_type = included->bus_type;

      included->bus_type = NULL;

    }

  if (included->fork)

    parser->fork = TRUE;

  if (included->pidfile != NULL)

    {

      dbus_free (parser->pidfile);

      parser->pidfile = included->pidfile;

      included->pidfile = NULL;

    }

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

    _dbus_list_append_link (&parser->listen_on, link);

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

    _dbus_list_append_link (&parser->mechanisms, link);

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

    service_dirs_append_link_unique_or_free (&parser->service_dirs, link);

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

    _dbus_list_append_link (&parser->conf_dirs, link);

  return TRUE;

}

static dbus_bool_t

seen_include (BusConfigParser  *parser,

	      const DBusString *file)

{

  DBusList *iter;

  iter = parser->included_files;

  while (iter != NULL)

    {

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

	return TRUE;

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

    }

  return FALSE;

}

BusConfigParser*

bus_config_parser_new (const DBusString      *basedir,

                       dbus_bool_t            is_toplevel,

                       const BusConfigParser *parent)

{

  BusConfigParser *parser;

  parser = dbus_new0 (BusConfigParser, 1);

  if (parser == NULL)

    return NULL;

  parser->is_toplevel = !!is_toplevel;

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

    {

      dbus_free (parser);

      return NULL;

    }

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

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

      ((parser->service_context_table = _dbus_hash_table_new (DBUS_HASH_STRING,

							      dbus_free,

							      dbus_free)) == NULL))

    {

      if (parser->policy)

        bus_policy_unref (parser->policy);

      _dbus_string_free (&parser->basedir);

      dbus_free (parser);

      return NULL;

    }

  if (parent != NULL)

    {

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

      parser->limits = parent->limits;

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

	 circular inclusions. */

      parser->included_files = parent->included_files;

    }

  else

    {

      /* Make up some numbers! woot! */

      parser->limits.max_incoming_bytes = _DBUS_ONE_MEGABYTE * 63;

      parser->limits.max_outgoing_bytes = _DBUS_ONE_MEGABYTE * 63;

      parser->limits.max_message_size = _DBUS_ONE_MEGABYTE * 32;

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

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

       * they might see a false failure.

       */

#ifdef __SYMBIAN32__

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

#else

      parser->limits.activation_timeout = 25000; 

#endif

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

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

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

       */

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

      parser->limits.max_incomplete_connections = 32;

      parser->limits.max_connections_per_user = 128;

      /* Note that max_completed_connections / max_connections_per_user

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

       * DOS all the other users.

       */

      parser->limits.max_completed_connections = 1024;

      parser->limits.max_pending_activations = 256;

      parser->limits.max_services_per_connection = 256;

      parser->limits.max_match_rules_per_connection = 512;

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

      parser->limits.max_replies_per_connection = 32;

      /*

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

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

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

      parser->limits.activation_timeout = 250000;

      parser->limits.auth_timeout = 300000;

      parser->limits.max_incomplete_connections = 32;

      parser->limits.max_connections_per_user = 128;

      parser->limits.max_completed_connections = 1024;

      parser->limits.max_pending_activations = 256;

      parser->limits.max_services_per_connection = 256;

      parser->limits.max_match_rules_per_connection = 512;

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

      parser->limits.max_replies_per_connection = 32;

      */

    }

  parser->refcount = 1;

  return parser;

}