/* -*- 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;