ibus/bus/matchrule.c

/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
/* vim:set et sts=4: */
/* IBus - The Input Bus
 * Copyright (C) 2008-2010 Peng Huang <shawn.p.huang@gmail.com>
 * Copyright (C) 2008-2010 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
 * USA
 */

#include "matchrule.h"

#include <string.h>

#include "dbusimpl.h"

typedef enum {
    MATCH_TYPE          = 1 << 0,
    MATCH_INTERFACE     = 1 << 1,
    MATCH_MEMBER        = 1 << 2,
    MATCH_SENDER        = 1 << 3,
    MATCH_DESTINATION   = 1 << 4,
    MATCH_PATH          = 1 << 5,
    MATCH_ARGS          = 1 << 6,
} BusMatchFlags;

struct _BusMatchRule {
    IBusObject parent;
    /* instance members */
    gint   flags;
    gint   message_type;
    gchar *interface;
    gchar *member;
    gchar *sender;
    gchar *destination;
    gchar *path;
    GArray *args;
    GList *recipients;
};

struct _BusMatchRuleClass {
    IBusObjectClass parent;
    /* class members */
};

typedef struct _BusRecipient BusRecipient;
struct _BusRecipient {
    BusConnection *connection;
    gint refcount;
};

static BusRecipient *bus_recipient_new          (BusConnection      *connection);
static void          bus_recipient_free         (BusRecipient       *recipient);
static BusRecipient *bus_recipient_ref          (BusRecipient       *recipient);
static gboolean      bus_recipient_unref        (BusRecipient       *recipient);
static void          bus_match_rule_destroy     (BusMatchRule       *rule);
static void          bus_match_rule_connection_destroy_cb
                                                (BusConnection      *connection,
                                                 BusMatchRule       *rule);

static BusRecipient *
bus_recipient_new (BusConnection *connection)
{
    BusRecipient *recipient = g_slice_new (BusRecipient);
    g_object_ref (connection);
    recipient->connection = connection;
    recipient->refcount = 1;
    return recipient;
}

static void
bus_recipient_free (BusRecipient *recipient)
{
    g_object_unref (recipient->connection);
    g_slice_free (BusRecipient, recipient);
}

static BusRecipient *
bus_recipient_ref (BusRecipient *recipient)
{
    recipient->refcount ++;
    return recipient;
}

static gboolean
bus_recipient_unref (BusRecipient *recipient)
{
    recipient->refcount --;
    if (recipient->refcount == 0) {
        bus_recipient_free (recipient);
        return TRUE;
    }
    return FALSE;
}

G_DEFINE_TYPE (BusMatchRule, bus_match_rule, IBUS_TYPE_OBJECT)

static void
bus_match_rule_class_init (BusMatchRuleClass *class)
{
    IBusObjectClass *ibus_object_class = IBUS_OBJECT_CLASS (class);

    ibus_object_class->destroy = (IBusObjectDestroyFunc) bus_match_rule_destroy;
}

static void
bus_match_rule_init (BusMatchRule *rule)
{
    rule->flags = 0;
    rule->message_type = G_DBUS_MESSAGE_TYPE_INVALID;
    rule->interface = NULL;
    rule->member = NULL;
    rule->sender = NULL;
    rule->destination = NULL;
    rule->path = NULL;
    rule->args = g_array_new (TRUE, TRUE, sizeof (gchar *));
}

static void
bus_match_rule_destroy (BusMatchRule *rule)
{
    g_free (rule->interface);
    g_free (rule->member);
    g_free (rule->sender);
    g_free (rule->destination);
    g_free (rule->path);

    gint i;
    for (i = 0; i < rule->args->len; i++) {
        g_free (g_array_index (rule->args, gchar *, i));
    }
    g_array_free (rule->args, TRUE);

    GList *p;
    for (p = rule->recipients; p != NULL; p = p->next) {
        BusRecipient *recipient = (BusRecipient *) p->data;
        g_signal_handlers_disconnect_by_func (recipient->connection,
                                              G_CALLBACK (bus_match_rule_connection_destroy_cb), rule);
        bus_recipient_free (recipient);
    }
    g_list_free (rule->recipients);

    IBUS_OBJECT_CLASS(bus_match_rule_parent_class)->destroy (IBUS_OBJECT (rule));
}


typedef struct _Token {
    gchar *key;
    gchar *value;
} Token;

#define SKIP_WHITE(a)   \
    while (*(a) == ' ' || *(a) == '\t' || *(a) == '\n') { (a)++; }
#define IS_ALPHA(a) \
    ((*(a) >= 'a' && *(a) <= 'z') || (*(a) >= 'A' && *(a) <= 'Z'))
#define IS_NUMBER(a) \
    (*(a) >= '0' && *(a) <= '9')

static gchar *
find_key (const gchar **p)
{
    GString *text;

    text = g_string_new ("");

    SKIP_WHITE(*p)
    if (!IS_ALPHA (*p))
        goto failed;

    g_string_append_c (text, **p);
    (*p) ++;

    while (IS_ALPHA (*p) || IS_NUMBER (*p)) {
        g_string_append_c (text, **p);
        (*p) ++;
    }

    return g_string_free (text, FALSE);

failed:
    g_string_free (text, TRUE);
    return NULL;

}

static gchar *
find_value (const gchar **p)
{
    SKIP_WHITE (*p);

    if (**p == '\'') {
        GString *text = g_string_new ("");
        (*p) ++;
        while (**p != '\'') {
            if (**p == '\0') {
                g_string_free (text, TRUE);
                return NULL;
            }
            if (**p == '\\')
                (*p) ++;
            g_string_append_c (text, **p);
            (*p) ++;
        }
        (*p) ++;
        return g_string_free (text, FALSE);
    } else if (strncmp (*p, "true", 4) == 0) {
        *p += 4;
        return g_strdup ("true");
    } else if (strncmp (*p, "false", 5) == 0) {
        *p += 5;
        return g_strdup ("false");
    }

    return NULL;
}

static Token *
tokenize_rule (const gchar *text)
{
    GArray *tokens;
    Token token;
    const gchar *p;
    gint i;

    tokens = g_array_new (TRUE, TRUE, sizeof (Token));

    p = text;

    while (*p != '\0') {
        gchar *key;
        gchar *value;

        SKIP_WHITE (p);
        key = find_key (&p);
        if (key == NULL)
            goto failed;
        SKIP_WHITE (p);
        if (*p != '=')
            goto failed;
        p ++;
        SKIP_WHITE (p);
        value = find_value (&p);
        if (value == NULL) {
            g_free (key);
            goto failed;
        }
        SKIP_WHITE (p);
        if (*p != ',' && *p != '\0') {
            g_free (key);
            g_free (value);
            goto failed;
        }

        if (*p == ',')
         p ++;
        token.key = key;
        token.value = value;
        g_array_append_val (tokens, token);
    }

    return (Token *)g_array_free (tokens, FALSE);

failed:
    for (i = 0; i < tokens->len; i++) {
        Token *p = &g_array_index (tokens, Token, i);
        g_free (p->key);
        g_free (p->value);
    }

    g_array_free (tokens, TRUE);
    return NULL;
}

static void
tokens_free (Token *tokens)
{
    Token *p;
    p = tokens;

    while (p != NULL && p->key != NULL) {
        g_free (p->key);
        g_free (p->value);
        p ++;
    }
    g_free (tokens);
}

static gboolean
_atoi (const gchar *text, gint *i)
{
    const gchar *p = text;
    *i = 0;
    while (*p != '\0') {
        if (!IS_NUMBER(p))
            return FALSE;
        *i = (*i) * 10 - '0'  + *p;
        p ++;
    }
    return TRUE;
}

BusMatchRule *
bus_match_rule_new (const gchar *text)
{
    g_assert (text != NULL);

    Token *tokens, *p;
    BusMatchRule *rule;

    rule = BUS_MATCH_RULE (g_object_new (BUS_TYPE_MATCH_RULE, NULL));

    /* parse rule */
    tokens = tokenize_rule (text);

    if (tokens == NULL)
        goto failed;

    for (p = tokens; p != NULL && p->key != 0; p++) {
        if (g_strcmp0 (p->key, "type") == 0) {
            if (g_strcmp0 (p->value, "signal") == 0) {
                bus_match_rule_set_message_type (rule, G_DBUS_MESSAGE_TYPE_SIGNAL);
            }
            else if (g_strcmp0 (p->value, "method_call") == 0) {
                bus_match_rule_set_message_type (rule, G_DBUS_MESSAGE_TYPE_METHOD_CALL);
            }
            else if (g_strcmp0 (p->value, "method_return") == 0) {
                bus_match_rule_set_message_type (rule, G_DBUS_MESSAGE_TYPE_METHOD_RETURN);
            }
            else if (g_strcmp0 (p->value, "error") == 0) {
                bus_match_rule_set_message_type (rule, G_DBUS_MESSAGE_TYPE_ERROR);
            }
            else
                goto failed;
        }
        else if (g_strcmp0 (p->key, "sender") == 0) {
            if (!g_dbus_is_name (p->value))
                goto failed;
            bus_match_rule_set_sender (rule, p->value);
        }
        else if (g_strcmp0 (p->key, "interface") == 0) {
            if (!g_dbus_is_interface_name (p->value))
                goto failed;
            bus_match_rule_set_interface (rule, p->value);
        }
        else if (g_strcmp0 (p->key, "member") == 0) {
            if (!g_dbus_is_member_name (p->value))
                goto failed;
            bus_match_rule_set_member (rule, p->value);
        }
        else if (g_strcmp0 (p->key, "path") == 0) {
            bus_match_rule_set_path (rule, p->value);
        }
        else if (g_strcmp0 (p->key, "destination") == 0) {
            if (!g_dbus_is_name (p->value))
                goto failed;
            bus_match_rule_set_destination (rule, p->value);
        }
        else if (strncmp (p->key, "arg", 3) == 0) {
            gint i;
            if (! _atoi (p->key + 3, &i))
                goto failed;
            bus_match_rule_set_arg (rule, i, p->value);
        }
        else if (g_strcmp0 (p->key, "eavesdrop") == 0) {
            if (g_strcmp0 (p->value, "true") != 0 &&
                g_strcmp0 (p->value, "false") != 0)
                goto failed;
        }
        else
            goto failed;
    }

    tokens_free (tokens);
    return rule;

failed:
    tokens_free (tokens);
    g_object_unref (rule);
    return NULL;
}

gboolean
bus_match_rule_set_message_type (BusMatchRule   *rule,
                                 gint            type)
{
    g_assert (rule != NULL);
    g_assert (type == G_DBUS_MESSAGE_TYPE_SIGNAL ||
              type == G_DBUS_MESSAGE_TYPE_METHOD_CALL ||
              type == G_DBUS_MESSAGE_TYPE_METHOD_RETURN ||
              type == G_DBUS_MESSAGE_TYPE_ERROR);

    rule->flags |= MATCH_TYPE;
    rule->message_type = type;

    return TRUE;
}

gboolean
bus_match_rule_set_sender  (BusMatchRule    *rule,
                            const gchar     *sender)
{
    g_assert (rule != NULL);
    g_assert (sender != NULL);

    rule->flags |= MATCH_SENDER;

    g_free (rule->sender);
    rule->sender = g_strdup (sender);

    return TRUE;
}

gboolean
bus_match_rule_set_interface (BusMatchRule   *rule,
                              const gchar    *interface)
{
    g_assert (rule != NULL);
    g_assert (interface != NULL);

    rule->flags |= MATCH_INTERFACE;

    g_free (rule->interface);
    rule->interface = g_strdup (interface);
    return TRUE;
}

gboolean
bus_match_rule_set_member (BusMatchRule   *rule,
                           const gchar    *member)
{
    g_assert (rule != NULL);
    g_assert (member != NULL);

    rule->flags |= MATCH_MEMBER;

    g_free (rule->member);
    rule->member = g_strdup (member);

    return TRUE;
}

gboolean
bus_match_rule_set_path (BusMatchRule   *rule,
                         const gchar    *path)
{
    g_assert (rule != NULL);
    g_assert (path != NULL);

    rule->flags |= MATCH_PATH;

    g_free (rule->path);
    rule->path = g_strdup (path);

    return TRUE;
}

gboolean
bus_match_rule_set_destination (BusMatchRule   *rule,
                                const gchar    *dest)
{
    g_assert (rule != NULL);
    g_assert (dest != NULL);

    rule->flags |= MATCH_DESTINATION;

    g_free (rule->destination);
    rule->destination = g_strdup (dest);

    return TRUE;
}

gboolean
bus_match_rule_set_arg (BusMatchRule   *rule,
                        guint           arg_i,
                        const gchar    *arg)
{
    g_assert (rule != NULL);
    g_assert (arg != NULL);

    rule->flags |= MATCH_ARGS;

    if (arg_i >= rule->args->len) {
        g_array_set_size (rule->args, arg_i + 1);
    }

    g_free (g_array_index (rule->args, gchar *, arg_i));
    g_array_index (rule->args, gchar *, arg_i) = g_strdup (arg);
    return TRUE;
}

static gboolean
bus_match_rule_match_name (const gchar *name,
                           const gchar *match_name)
{
    if (g_dbus_is_unique_name (name) && !g_dbus_is_unique_name (match_name)) {
        BusConnection *connection =
                bus_dbus_impl_get_connection_by_name (BUS_DEFAULT_DBUS, match_name);
        if (connection == NULL)
            return FALSE;
        return g_strcmp0 (name, bus_connection_get_unique_name (connection)) == 0;
    }
    return g_strcmp0 (name, match_name) == 0;
}

gboolean
bus_match_rule_match (BusMatchRule   *rule,
                      GDBusMessage   *message)
{
    g_assert (rule != NULL);
    g_assert (message != NULL);

    if (rule->flags & MATCH_TYPE) {
        if (g_dbus_message_get_message_type (message) != rule->message_type)
            return FALSE;
    }

    if (rule->flags & MATCH_INTERFACE) {
        if (g_strcmp0 (g_dbus_message_get_interface (message), rule->interface) != 0)
            return FALSE;
    }

    if (rule->flags & MATCH_MEMBER) {
        if (g_strcmp0 (g_dbus_message_get_member (message), rule->member) != 0)
            return FALSE;
    }

    if (rule->flags & MATCH_SENDER) {
        if (!bus_match_rule_match_name (g_dbus_message_get_sender (message), rule->sender))
            return FALSE;
    }

    if (rule->flags & MATCH_DESTINATION) {
        if (!bus_match_rule_match_name (g_dbus_message_get_destination (message), rule->destination))
            return FALSE;
    }

    if (rule->flags & MATCH_PATH) {
        if (g_strcmp0 (g_dbus_message_get_path (message), rule->path) != 0)
            return FALSE;
    }

    if (rule->flags & MATCH_ARGS) {
        guint i;
        GVariant *arguments = g_dbus_message_get_body (message);
        if (arguments == NULL)
            return FALSE;

        for (i = 0; i < rule->args->len; i++) {
            const gchar *arg = g_array_index (rule->args, const gchar *, i);
            if (arg == NULL)
                continue;
            GVariant * variant = g_variant_get_child_value (arguments, i);
            if (variant == NULL)
                return FALSE;
            switch (g_variant_classify (variant)) {
            case G_VARIANT_CLASS_STRING:
            case G_VARIANT_CLASS_OBJECT_PATH:
                if (g_strcmp0 (arg, g_variant_get_string (variant, NULL)) == 0) {
                    g_variant_unref (variant);
                    continue;
                }
            default:
                break;
            }
            g_variant_unref (variant);
            return FALSE;
        }
    }
    return TRUE;
}

gboolean
bus_match_rule_is_equal (BusMatchRule   *a,
                         BusMatchRule   *b)
{
    g_assert (a != NULL);
    g_assert (b != NULL);

    if (a->flags != b->flags)
        return FALSE;

    if (a->flags & MATCH_TYPE) {
        if (a->message_type != b->message_type)
            return FALSE;
    }

    if (a->flags & MATCH_INTERFACE) {
        if (g_strcmp0 (a->interface, b->interface) != 0)
            return FALSE;
    }

    if (a->flags & MATCH_MEMBER) {
        if (g_strcmp0 (a->member, b->member) != 0)
            return FALSE;
    }

    if (a->flags & MATCH_SENDER) {
        if (g_strcmp0 (a->sender, b->sender) != 0)
            return FALSE;
    }

    if (a->flags & MATCH_DESTINATION) {
        if (g_strcmp0 (a->destination, b->destination) != 0)
            return FALSE;
    }

    if (a->flags & MATCH_PATH) {
        if (g_strcmp0 (a->path, b->path) != 0)
            return FALSE;
    }

    if (a->flags & MATCH_ARGS) {
        if (a->args->len != b->args->len)
            return FALSE;

        gint i;

        for (i = 0; i < a->args->len; i++) {
            if (g_strcmp0 (g_array_index (a->args, gchar *, i),
                           g_array_index (b->args, gchar *, i)) != 0)
                return FALSE;
        }
    }

    return TRUE;
}

static void
bus_match_rule_connection_destroy_cb (BusConnection *connection,
                                      BusMatchRule  *rule)
{
    GList *p;
    for (p = rule->recipients; p != NULL; p = p->next) {
        BusRecipient *recipient = (BusRecipient *)p->data;

        if (recipient->connection == connection) {
            rule->recipients = g_list_remove_link (rule->recipients, p);
            bus_recipient_free (recipient);
            return;
        }

        if (rule->recipients == NULL) {
            ibus_object_destroy (IBUS_OBJECT (rule));
        }
    }
    g_assert_not_reached ();
}

void
bus_match_rule_add_recipient (BusMatchRule    *rule,
                              BusConnection   *connection)
{
    g_assert (BUS_IS_MATCH_RULE (rule));
    g_assert (BUS_IS_CONNECTION (connection));

    GList *p;
    for (p = rule->recipients; p != NULL; p = p->next) {
        BusRecipient *recipient = (BusRecipient *) p->data;
        if (connection == recipient->connection) {
            bus_recipient_ref (recipient);
            return;
        }
    }

    /* alloc a new recipient */
    BusRecipient *recipient = bus_recipient_new (connection);
    rule->recipients = g_list_append (rule->recipients, recipient);
    g_signal_connect (connection,
                      "destroy",
                      G_CALLBACK (bus_match_rule_connection_destroy_cb),
                      rule);
}

void
bus_match_rule_remove_recipient (BusMatchRule  *rule,
                                 BusConnection *connection)
{
    g_assert (BUS_IS_MATCH_RULE (rule));
    g_assert (BUS_IS_CONNECTION (connection));

    GList *p;
    for (p = rule->recipients; p != NULL; p = p->next) {
        BusRecipient *recipient = (BusRecipient *) p->data;
        if (connection == recipient->connection) {
            if (bus_recipient_unref (recipient)) {
                rule->recipients = g_list_remove_link (rule->recipients, p);
                g_signal_handlers_disconnect_by_func (connection,
                                                      G_CALLBACK (bus_match_rule_connection_destroy_cb),
                                                      rule);
            }

            if (rule->recipients == NULL ) {
                ibus_object_destroy (IBUS_OBJECT(rule));
            }
            return;
        }
    }
    g_return_if_reached ();
}

GList *
bus_match_rule_get_recipients (BusMatchRule   *rule,
                               GDBusMessage   *message)
{
    g_assert (BUS_IS_MATCH_RULE (rule));
    g_assert (message != NULL);

    GList *link;
    GList *recipients = NULL;

    if (!bus_match_rule_match (rule, message))
        return FALSE;

    for (link = rule->recipients; link != NULL; link = link->next) {
        BusRecipient *recipient = (BusRecipient *) link->data;

        recipients = g_list_append (recipients, recipient->connection);
    }

    return recipients;
}