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

/* signals.c  Bus signal connection implementation

 *

 * Copyright (C) 2003, 2005  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 "signals.h"

#include "services.h"

#include "utils.h"

#ifndef __SYMBIAN32__

#include <dbus/dbus-marshal-validate.h>

#else

#include "dbus-marshal-validate.h"

#include "config.h"

#endif //__SYMBIAN32__

struct BusMatchRule

{

  int refcount;       /**< reference count */

  DBusConnection *matches_go_to; /**< Owner of the rule */

  unsigned int flags; /**< BusMatchFlags */

  int   message_type;

  char *interface;

  char *member;

  char *sender;

  char *destination;

  char *path;

  char **args;

  int args_len;

};

BusMatchRule*

bus_match_rule_new (DBusConnection *matches_go_to)

{

  BusMatchRule *rule;

  rule = dbus_new0 (BusMatchRule, 1);

  if (rule == NULL)

    return NULL;

  rule->refcount = 1;

  rule->matches_go_to = matches_go_to;

#ifndef DBUS_BUILD_TESTS

  _dbus_assert (rule->matches_go_to != NULL);

#endif

  return rule;

}

BusMatchRule *

bus_match_rule_ref (BusMatchRule *rule)

{

  _dbus_assert (rule->refcount > 0);

  rule->refcount += 1;

  return rule;

}

void

bus_match_rule_unref (BusMatchRule *rule)

{

  _dbus_assert (rule->refcount > 0);

  rule->refcount -= 1;

  if (rule->refcount == 0)

    {

      dbus_free (rule->interface);

      dbus_free (rule->member);

      dbus_free (rule->sender);

      dbus_free (rule->destination);

      dbus_free (rule->path);

      /* can't use dbus_free_string_array() since there

       * are embedded NULL

       */

      if (rule->args)

        {

          int i;

          i = 0;

          while (i < rule->args_len)

            {

              if (rule->args[i])

                dbus_free (rule->args[i]);

              ++i;

            }

          dbus_free (rule->args);

        }

      dbus_free (rule);

    }

}

#ifdef DBUS_ENABLE_VERBOSE_MODE

/* Note this function does not do escaping, so it's only

 * good for debug spew at the moment

 */

static char*

match_rule_to_string (BusMatchRule *rule)

{

  DBusString str;

  char *ret;

  if (!_dbus_string_init (&str))

    {

      char *s;

      while ((s = _dbus_strdup ("nomem")) == NULL)

        ; /* only OK for debug spew... */

      return s;

    }

  if (rule->flags & BUS_MATCH_MESSAGE_TYPE)

    {

      /* FIXME make type readable */

      if (!_dbus_string_append_printf (&str, "type='%d'", rule->message_type))

        goto nomem;

    }

  if (rule->flags & BUS_MATCH_INTERFACE)

    {

      if (_dbus_string_get_length (&str) > 0)

        {

          if (!_dbus_string_append (&str, ","))

            goto nomem;

        }

      if (!_dbus_string_append_printf (&str, "interface='%s'", rule->interface))

        goto nomem;

    }

  if (rule->flags & BUS_MATCH_MEMBER)

    {

      if (_dbus_string_get_length (&str) > 0)

        {

          if (!_dbus_string_append (&str, ","))

            goto nomem;

        }

      if (!_dbus_string_append_printf (&str, "member='%s'", rule->member))

        goto nomem;

    }

  if (rule->flags & BUS_MATCH_PATH)

    {

      if (_dbus_string_get_length (&str) > 0)

        {

          if (!_dbus_string_append (&str, ","))

            goto nomem;

        }

      if (!_dbus_string_append_printf (&str, "path='%s'", rule->path))

        goto nomem;

    }

  if (rule->flags & BUS_MATCH_SENDER)

    {

      if (_dbus_string_get_length (&str) > 0)

        {

          if (!_dbus_string_append (&str, ","))

            goto nomem;

        }

      if (!_dbus_string_append_printf (&str, "sender='%s'", rule->sender))

        goto nomem;

    }

  if (rule->flags & BUS_MATCH_DESTINATION)

    {

      if (_dbus_string_get_length (&str) > 0)

        {

          if (!_dbus_string_append (&str, ","))

            goto nomem;

        }

      if (!_dbus_string_append_printf (&str, "destination='%s'", rule->destination))

        goto nomem;

    }

  if (rule->flags & BUS_MATCH_ARGS)

    {

      int i;

      _dbus_assert (rule->args != NULL);

      i = 0;

      while (i < rule->args_len)

        {

          if (rule->args[i] != NULL)

            {

              if (_dbus_string_get_length (&str) > 0)

                {

                  if (!_dbus_string_append (&str, ","))

                    goto nomem;

                }

              if (!_dbus_string_append_printf (&str,

                                               "arg%d='%s'",

                                               i,

                                               rule->args[i]))

                goto nomem;

            }

          ++i;

        }

    }

  if (!_dbus_string_steal_data (&str, &ret))

    goto nomem;

  _dbus_string_free (&str);

  return ret;

 nomem:

  _dbus_string_free (&str);

  {

    char *s;

    while ((s = _dbus_strdup ("nomem")) == NULL)

      ;  /* only OK for debug spew... */

    return s;

  }

}

#endif /* DBUS_ENABLE_VERBOSE_MODE */

dbus_bool_t

bus_match_rule_set_message_type (BusMatchRule *rule,

                                 int           type)

{

  rule->flags |= BUS_MATCH_MESSAGE_TYPE;

  rule->message_type = type;

  return TRUE;

}

dbus_bool_t

bus_match_rule_set_interface (BusMatchRule *rule,

                              const char   *interface)

{

  char *new;

  _dbus_assert (interface != NULL);

  new = _dbus_strdup (interface);

  if (new == NULL)

    return FALSE;

  rule->flags |= BUS_MATCH_INTERFACE;

  dbus_free (rule->interface);

  rule->interface = new;

  return TRUE;

}

dbus_bool_t

bus_match_rule_set_member (BusMatchRule *rule,

                           const char   *member)

{

  char *new;

  _dbus_assert (member != NULL);

  new = _dbus_strdup (member);

  if (new == NULL)

    return FALSE;

  rule->flags |= BUS_MATCH_MEMBER;

  dbus_free (rule->member);

  rule->member = new;

  return TRUE;

}

dbus_bool_t

bus_match_rule_set_sender (BusMatchRule *rule,

                           const char   *sender)

{

  char *new;

  _dbus_assert (sender != NULL);

  new = _dbus_strdup (sender);

  if (new == NULL)

    return FALSE;

  rule->flags |= BUS_MATCH_SENDER;

  dbus_free (rule->sender);

  rule->sender = new;

  return TRUE;

}

dbus_bool_t

bus_match_rule_set_destination (BusMatchRule *rule,

                                const char   *destination)

{

  char *new;

  _dbus_assert (destination != NULL);

  new = _dbus_strdup (destination);

  if (new == NULL)

    return FALSE;

  rule->flags |= BUS_MATCH_DESTINATION;

  dbus_free (rule->destination);

  rule->destination = new;

  return TRUE;

}

dbus_bool_t

bus_match_rule_set_path (BusMatchRule *rule,

                         const char   *path)

{

  char *new;

  _dbus_assert (path != NULL);

  new = _dbus_strdup (path);

  if (new == NULL)

    return FALSE;

  rule->flags |= BUS_MATCH_PATH;

  dbus_free (rule->path);

  rule->path = new;

  return TRUE;

}

dbus_bool_t

bus_match_rule_set_arg (BusMatchRule *rule,

                        int           arg,

                        const char   *value)

{

  char *new;

  _dbus_assert (value != NULL);

  new = _dbus_strdup (value);

  if (new == NULL)

    return FALSE;

  /* args_len is the number of args not including null termination

   * in the char**

   */

  if (arg >= rule->args_len)

    {

      char **new_args;

      int new_args_len;

      int i;

      new_args_len = arg + 1;

      /* add another + 1 here for null termination */

      new_args = dbus_realloc (rule->args,

                               sizeof(rule->args[0]) * (new_args_len + 1));

      if (new_args == NULL)

        {

          dbus_free (new);

          return FALSE;

        }

      /* NULL the new slots */

      i = rule->args_len;

      while (i <= new_args_len) /* <= for null termination */

        {

          new_args[i] = NULL;

          ++i;

        }

      rule->args = new_args;

      rule->args_len = new_args_len;

    }

  rule->flags |= BUS_MATCH_ARGS;

  dbus_free (rule->args[arg]);

  rule->args[arg] = new;

  /* NULL termination didn't get busted */

  _dbus_assert (rule->args[rule->args_len] == NULL);

  return TRUE;

}

#define ISWHITE(c) (((c) == ' ') || ((c) == '\t') || ((c) == '\n') || ((c) == '\r'))

static dbus_bool_t

find_key (const DBusString *str,

          int               start,

          DBusString       *key,

          int              *value_pos,

          DBusError        *error)

{

  const char *p;

  const char *s;

  const char *key_start;

  const char *key_end;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  s = _dbus_string_get_const_data (str);

  p = s + start;

  while (*p && ISWHITE (*p))

    ++p;

  key_start = p;

  while (*p && *p != '=' && !ISWHITE (*p))

    ++p;

  key_end = p;

  while (*p && ISWHITE (*p))

    ++p;

  if (key_start == key_end)

    {

      /* Empty match rules or trailing whitespace are OK */

      *value_pos = p - s;

      return TRUE;

    }

  if (*p != '=')

    {

      dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                      "Match rule has a key with no subsequent '=' character");

      return FALSE;

    }

  ++p;

  if (!_dbus_string_append_len (key, key_start, key_end - key_start))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  *value_pos = p - s;

  return TRUE;

}

static dbus_bool_t

find_value (const DBusString *str,

            int               start,

            const char       *key,

            DBusString       *value,

            int              *value_end,

            DBusError        *error)

{

  const char *p;

  const char *s;

  char quote_char;

  int orig_len;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  orig_len = _dbus_string_get_length (value);

  s = _dbus_string_get_const_data (str);

  p = s + start;

  quote_char = '\0';

  while (*p)

    {

      if (quote_char == '\0')

        {

          switch (*p)

            {

            case '\0':

              goto done;

            case '\'':

              quote_char = '\'';

              goto next;

            case ',':

              ++p;

              goto done;

            case '\\':

              quote_char = '\\';

              goto next;

            default:

              if (!_dbus_string_append_byte (value, *p))

                {

                  BUS_SET_OOM (error);

                  goto failed;

                }

            }

        }

      else if (quote_char == '\\')

        {

          /* \ only counts as an escape if escaping a quote mark */

          if (*p != '\'')

            {

              if (!_dbus_string_append_byte (value, '\\'))

                {

                  BUS_SET_OOM (error);

                  goto failed;

                }

            }

          if (!_dbus_string_append_byte (value, *p))

            {

              BUS_SET_OOM (error);

              goto failed;

            }

          quote_char = '\0';

        }

      else

        {

          _dbus_assert (quote_char == '\'');

          if (*p == '\'')

            {

              quote_char = '\0';

            }

          else

            {

              if (!_dbus_string_append_byte (value, *p))

                {

                  BUS_SET_OOM (error);

                  goto failed;

                }

            }

        }

    next:

      ++p;

    }

 done:

  if (quote_char == '\\')

    {

      if (!_dbus_string_append_byte (value, '\\'))

        {

          BUS_SET_OOM (error);

          goto failed;

        }

    }

  else if (quote_char == '\'')

    {

      dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                      "Unbalanced quotation marks in match rule");

      goto failed;

    }

  else

    _dbus_assert (quote_char == '\0');

  /* Zero-length values are allowed */

  *value_end = p - s;

  return TRUE;

 failed:

  _DBUS_ASSERT_ERROR_IS_SET (error);

  _dbus_string_set_length (value, orig_len);

  return FALSE;

}

/* duplicates aren't allowed so the real legitimate max is only 6 or

 * so. Leaving extra so we don't have to bother to update it.

 * FIXME this is sort of busted now with arg matching, but we let

 * you match on up to 10 args for now

 */

#define MAX_RULE_TOKENS 16

/* this is slightly too high level to be termed a "token"

 * but let's not be pedantic.

 */

typedef struct

{

  char *key;

  char *value;

} RuleToken;

static dbus_bool_t

tokenize_rule (const DBusString *rule_text,

               RuleToken         tokens[MAX_RULE_TOKENS],

               DBusError        *error) 

{

  int i;

  int pos;

  DBusString key;

  DBusString value;

  dbus_bool_t retval;

  retval = FALSE;

  if (!_dbus_string_init (&key))

    {

      BUS_SET_OOM (error);

      return FALSE;

    }

  if (!_dbus_string_init (&value))

    {

      _dbus_string_free (&key);

      BUS_SET_OOM (error);

      return FALSE;

    }

  i = 0;

  pos = 0;

  while (i < MAX_RULE_TOKENS &&

         pos < _dbus_string_get_length (rule_text))

    {

      _dbus_assert (tokens[i].key == NULL);

      _dbus_assert (tokens[i].value == NULL);

      if (!find_key (rule_text, pos, &key, &pos, error))

        goto out;

      if (_dbus_string_get_length (&key) == 0)

        goto next;

      if (!_dbus_string_steal_data (&key, &tokens[i].key))

        {

          BUS_SET_OOM (error);

          goto out;

        }

      if (!find_value (rule_text, pos, tokens[i].key, &value, &pos, error))

        goto out;

      if (!_dbus_string_steal_data (&value, &tokens[i].value))

        {

          BUS_SET_OOM (error);

          goto out;

        }

    next:

      ++i;

    }

  retval = TRUE;

 out:

  if (!retval)

    {

      i = 0;

      while (tokens[i].key || tokens[i].value)

        {

          dbus_free (tokens[i].key);

          dbus_free (tokens[i].value);

          tokens[i].key = NULL;

          tokens[i].value = NULL;

          ++i;

        }

    }

  _dbus_string_free (&key);

  _dbus_string_free (&value);

  return retval;

}

static dbus_bool_t

bus_match_rule_parse_arg_match (BusMatchRule     *rule,

                                const char       *key,

                                const DBusString *value,

                                DBusError        *error)

{

  DBusString key_str;

  unsigned long arg;

  int end;

  /* For now, arg0='foo' always implies that 'foo' is a

   * DBUS_TYPE_STRING. Someday we could add an arg0type='int32' thing

   * if we wanted, which would specify another type, in which case

   * arg0='5' would have the 5 parsed as an int rather than string.

   */

  /* First we need to parse arg0 = 0, arg27 = 27 */

  _dbus_string_init_const (&key_str, key);

  if (_dbus_string_get_length (&key_str) < 4)

    {

      dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                      "Key '%s' in match rule starts with 'arg' but lacks an arg number. Should be 'arg0' or 'arg7' for example.\n", key);

      goto failed;

    }

  if (!_dbus_string_parse_uint (&key_str, 3, &arg, &end) ||

      end != _dbus_string_get_length (&key_str))

    {

      dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                      "Key '%s' in match rule starts with 'arg' but could not parse arg number. Should be 'arg0' or 'arg7' for example.\n", key);

      goto failed;

    }

  /* If we didn't check this we could allocate a huge amount of RAM */

  if (arg > DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER)

    {

      dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                      "Key '%s' in match rule has arg number %lu but the maximum is %d.\n", key, (unsigned long) arg, DBUS_MAXIMUM_MATCH_RULE_ARG_NUMBER);

      goto failed;

    }

  if ((rule->flags & BUS_MATCH_ARGS) &&

      rule->args_len > (int) arg &&

      rule->args[arg] != NULL)

    {

      dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                      "Key '%s' specified twice in match rule\n", key);

      goto failed;

    }

  if (!bus_match_rule_set_arg (rule, arg,

                               _dbus_string_get_const_data (value)))

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  return TRUE;

 failed:

  _DBUS_ASSERT_ERROR_IS_SET (error);

  return FALSE;

}

/*

 * The format is comma-separated with strings quoted with single quotes

 * as for the shell (to escape a literal single quote, use '\'').

 *

 * type='signal',sender='org.freedesktop.DBus',interface='org.freedesktop.DBus',member='Foo',

 * path='/bar/foo',destination=':452345.34'

 *

 */

BusMatchRule*

bus_match_rule_parse (DBusConnection   *matches_go_to,

                      const DBusString *rule_text,

                      DBusError        *error)

{

  BusMatchRule *rule;

  RuleToken tokens[MAX_RULE_TOKENS+1]; /* NULL termination + 1 */

  int i;

  _DBUS_ASSERT_ERROR_IS_CLEAR (error);

  if (_dbus_string_get_length (rule_text) > DBUS_MAXIMUM_MATCH_RULE_LENGTH)

    {

      dbus_set_error (error, DBUS_ERROR_LIMITS_EXCEEDED,

                      "Match rule text is %d bytes, maximum is %d",

                      _dbus_string_get_length (rule_text),

                      DBUS_MAXIMUM_MATCH_RULE_LENGTH);

      return NULL;

    }

  memset (tokens, '\0', sizeof (tokens));

  rule = bus_match_rule_new (matches_go_to);

  if (rule == NULL)

    {

      BUS_SET_OOM (error);

      goto failed;

    }

  if (!tokenize_rule (rule_text, tokens, error))

    goto failed;

  i = 0;

  while (tokens[i].key != NULL)

    {

      DBusString tmp_str;

      int len;

      const char *key = tokens[i].key;

      const char *value = tokens[i].value;

      _dbus_string_init_const (&tmp_str, value);

      len = _dbus_string_get_length (&tmp_str);

      if (strcmp (key, "type") == 0)

        {

          int t;

          if (rule->flags & BUS_MATCH_MESSAGE_TYPE)

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Key %s specified twice in match rule\n", key);

              goto failed;

            }

          t = dbus_message_type_from_string (value);

          if (t == DBUS_MESSAGE_TYPE_INVALID)

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Invalid message type (%s) in match rule\n", value);

              goto failed;

            }

          if (!bus_match_rule_set_message_type (rule, t))

            {

              BUS_SET_OOM (error);

              goto failed;

            }

        }

      else if (strcmp (key, "sender") == 0)

        {

          if (rule->flags & BUS_MATCH_SENDER)

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Key %s specified twice in match rule\n", key);

              goto failed;

            }

          if (!_dbus_validate_bus_name (&tmp_str, 0, len))

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Sender name '%s' is invalid\n", value);

              goto failed;

            }

          if (!bus_match_rule_set_sender (rule, value))

            {

              BUS_SET_OOM (error);

              goto failed;

            }

        }

      else if (strcmp (key, "interface") == 0)

        {

          if (rule->flags & BUS_MATCH_INTERFACE)

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Key %s specified twice in match rule\n", key);

              goto failed;

            }

          if (!_dbus_validate_interface (&tmp_str, 0, len))

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Interface name '%s' is invalid\n", value);

              goto failed;

            }

          if (!bus_match_rule_set_interface (rule, value))

            {

              BUS_SET_OOM (error);

              goto failed;

            }

        }

      else if (strcmp (key, "member") == 0)

        {

          if (rule->flags & BUS_MATCH_MEMBER)

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Key %s specified twice in match rule\n", key);

              goto failed;

            }

          if (!_dbus_validate_member (&tmp_str, 0, len))

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Member name '%s' is invalid\n", value);

              goto failed;

            }

          if (!bus_match_rule_set_member (rule, value))

            {

              BUS_SET_OOM (error);

              goto failed;

            }

        }

      else if (strcmp (key, "path") == 0)

        {

          if (rule->flags & BUS_MATCH_PATH)

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Key %s specified twice in match rule\n", key);

              goto failed;

            }

          if (!_dbus_validate_path (&tmp_str, 0, len))

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Path '%s' is invalid\n", value);

              goto failed;

            }

          if (!bus_match_rule_set_path (rule, value))

            {

              BUS_SET_OOM (error);

              goto failed;

            }

        }

      else if (strcmp (key, "destination") == 0)

        {

          if (rule->flags & BUS_MATCH_DESTINATION)

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Key %s specified twice in match rule\n", key);

              goto failed;

            }

          if (!_dbus_validate_bus_name (&tmp_str, 0, len))

            {

              dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                              "Destination name '%s' is invalid\n", value);

              goto failed;

            }

          if (!bus_match_rule_set_destination (rule, value))

            {

              BUS_SET_OOM (error);

              goto failed;

            }

        }

      else if (strncmp (key, "arg", 3) == 0)

        {

          if (!bus_match_rule_parse_arg_match (rule, key, &tmp_str, error))

            goto failed;

        }

      else

        {

          dbus_set_error (error, DBUS_ERROR_MATCH_RULE_INVALID,

                          "Unknown key \"%s\" in match rule",

                          key);

          goto failed;

        }

      ++i;

    }

  goto out;

 failed:

  _DBUS_ASSERT_ERROR_IS_SET (error);

  if (rule)

    {

      bus_match_rule_unref (rule);

      rule = NULL;

    }

 out:

  i = 0;

  while (tokens[i].key || tokens[i].value)

    {

      _dbus_assert (i < MAX_RULE_TOKENS);

      dbus_free (tokens[i].key);

      dbus_free (tokens[i].value);

      ++i;

    }

  return rule;

}

struct BusMatchmaker

{

  int refcount;

  DBusList *all_rules;

};

BusMatchmaker*

bus_matchmaker_new (void)

{

  BusMatchmaker *matchmaker;