/*
 * Copyright (C) 2013 Red Hat, Inc.
 * Authors:
 * Thomas Woerner <twoerner@redhat.com>
 *
 * 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, see <http://www.gnu.org/licenses/>.
 *
 */

#include "firewalld.h"
#include "functions.h"
#include "dbus.h"
#include "fwlog.h"
#include "fw.h"
#include <stdlib.h>
#include <string.h>

static const gchar introspection_xml[] =
    "<node>"
    "  <interface name='org.fedoraproject.FirewallD1'>"
    "    <method name='reload'>"
    "    </method>"
    "    <method name='getDefaultZone'>"
    "      <arg direction='out' type='s'/>"
    "    </method>"
    "    <method name='setDefaultZone'>"
    "      <arg direction='in'  type='s' name='zone'/>"
    "    </method>"
    "    <signal name='DefaultZoneChanged'>"
    "      <arg type='s' name='zone'/>"
    "    </signal>"
    "    <property type='s' name='version' access='read'/>"
    "    <property type='s' name='state' access='read'/>"
    "  </interface>"
    "  <interface name='org.fedoraproject.FirewallD1.zone'>"
    "    <method name='getZones'>"
    "      <arg direction='out' type='as'/>"
    "    </method>"
    "    <method name='getActiveZones'>"
    "      <arg direction='out' type='a{sa{sas}}'/>"
    "    </method>"
    "    <method name='addInterface'>"
    "      <arg type='s' name='zone'/>"
    "      <arg type='s' name='interface'/>"
    "      <arg direction='out' type='s'/>"
    "    </method>"
    "    <method name='changeZone'>"
    "      <arg type='s' name='zone'/>"
    "      <arg type='s' name='interface'/>"
    "      <arg direction='out' type='s'/>"
    "    </method>"
    "    <method name='changeZoneOfInterface'>"
    "      <arg type='s' name='zone'/>"
    "      <arg type='s' name='interface'/>"
    "      <arg direction='out' type='s'/>"
    "    </method>"
    "    <method name='getZoneOfInterface'>"
    "      <arg type='s' name='zone'/>"
    "      <arg direction='out' type='s'/>"
    "    </method>"
    "    <method name='queryInterface'>"
    "      <arg type='s' name='zone'/>"
    "      <arg type='s' name='interface'/>"
    "      <arg direction='out' type='b'/>"
    "    </method>"
    "    <method name='removeInterface'>"
    "      <arg type='s' name='zone'/>"
    "      <arg type='s' name='interface'/>"
    "      <arg direction='out' type='s'/>"
    "    </method>"
    "    <method name='getInterfaces'>"
    "      <arg type='s' name='zone'/>"
    "      <arg direction='out' type='as'/>"
    "    </method>"
    "    <signal name='InterfaceAdded'>"
    "      <arg type='s' name='zone'/>"
    "      <arg type='s' name='interface'/>"
    "    </signal>"
    "    <signal name='InterfaceRemoved'>"
    "      <arg type='s' name='zone'/>"
    "      <arg type='s' name='interface'/>"
    "    </signal>"
    "    <signal name='ZoneOfInterfaceChanged'>"
    "      <arg type='s' name='zone'/>"
    "      <arg type='s' name='interface'/>"
    "    </signal>"
    "  </interface>"
    "</node>";

static GDBusConnection *connection;
static guint name_id;

/* ************************************************************************* */

gchar *
dbus_check_zone(GDBusMethodInvocation *invocation,
		const gchar *zone)
{
    gchar *use_zone = fw_check_zone(zone);
    if ((size_t) use_zone == -1)
	g_dbus_method_invocation_return_dbus_error(invocation, DBUS_INTERFACE,
						   "INVALID_ZONE");
    return use_zone;
}

/* ************************************************************************* */

static void
dbus_handle_method_call(GDBusConnection *connection,
			const gchar *sender,
			const gchar *object_path,
			const gchar *interface_name,
			const gchar *method_name,
			GVariant *parameters,
			GDBusMethodInvocation *invocation,
			gpointer user_data)
{
    /* g_print(" --> dbus_handle_method_call(%s, %s, %s, %s)\n", sender,
       object_path, interface_name, method_name); */

    if (g_strcmp0(interface_name, DBUS_INTERFACE) == 0) {
	if (g_strcmp0(method_name, "reload") == 0) {
	    fwlog_debug1("reload");

	} else if (g_strcmp0(method_name, "getDefaultZone") == 0) {
	    fwlog_debug1("getDefaultZone()");
	    g_dbus_method_invocation_return_value(
		invocation, g_variant_new("(s)", fw_get_default_zone()));

	} else if (g_strcmp0(method_name, "setDefaultZone") == 0) {
	    gchar *use_zone, *zone;

	    g_variant_get(parameters, "(&s)", &zone);
	    fwlog_debug1("setDefaultZone(%s)", zone);

	    if (zone == NULL || strlen(zone) < 1) {
		g_dbus_method_invocation_return_dbus_error(invocation,
							   DBUS_INTERFACE,
							   "INVALID_ZONE");
		return;
	    }
	    use_zone = dbus_check_zone(invocation, zone);
	    if ((size_t) use_zone == -1)
		return;

	    if (fw_set_default_zone(use_zone)) {
		GError *error = NULL;
		g_dbus_connection_emit_signal(connection, NULL, object_path,
					      interface_name,
					      "DefaultZoneChanged",
					      g_variant_new("(s)", use_zone),
					      &error);
		g_assert_no_error(error);
		fwlog_debug1("DefaultZoneChanged('%s')", use_zone);
		g_dbus_method_invocation_return_value(invocation, NULL);
	    } else {
		g_dbus_method_invocation_return_dbus_error(invocation,
							   DBUS_INTERFACE,
							   "ZONE_ALREADY_SET");
	    }
	}

    } else if (g_strcmp0(interface_name, DBUS_INTERFACE_ZONE) == 0) {

	if (g_strcmp0(method_name, "getZones") == 0) {
	    GList *zones;
	    GVariantBuilder builder;
	    int i;

	    fwlog_debug1("getZones()");

	    zones = fw_get_zones();

	    g_variant_builder_init(&builder, G_VARIANT_TYPE("as"));
	    for (i=0; i<g_list_length(zones); i++) {
		g_variant_builder_add(&builder, "s", g_list_nth_data(zones, i));
	    }
	    g_dbus_method_invocation_return_value(invocation,
						  g_variant_new("(as)",
								&builder));

	} else if (g_strcmp0(method_name, "getActiveZones") == 0) {
	    GHashTable *active_zones;
	    GVariantBuilder builder, zone_builder;
	    GVariantBuilder ifs_builder, srcs_builder;
	    GHashTableIter zone_iter;
	    GHashTable *zone_hash;
	    const char *zone_name;
	    GList *interfaces, *sources;
	    gint i;

	    fwlog_debug1("getActiveZones()");

	    active_zones = fw_get_active_zones();

	    /* initialize builder */
	    g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sa{sas}}"));

	    /* walk active_zones */
	    g_hash_table_iter_init(&zone_iter, active_zones);
	    while (g_hash_table_iter_next(&zone_iter, (gpointer) &zone_name,
					  (gpointer) &zone_hash)) {
		/* initialize ifs_builder */
		g_variant_builder_init(&ifs_builder, G_VARIANT_TYPE("as"));

		/* add interfaces */
		interfaces = g_hash_table_lookup(zone_hash, "interfaces");
		if (interfaces != NULL) {
		    for (i=0; i<g_list_length(interfaces); i++) {
			g_variant_builder_add(&ifs_builder, "s",
					      g_list_nth_data(interfaces, i));
		    }
		}

		/* initialize srcs_builder */
		g_variant_builder_init(&srcs_builder, G_VARIANT_TYPE("as"));

		/* add sources */
		sources = g_hash_table_lookup(zone_hash, "sources");
		if (sources != NULL) {
		    for (i=0; i<g_list_length(sources); i++) {
			g_variant_builder_add(&srcs_builder, "s",
					      g_list_nth_data(sources, i));
		    }
		}

		/* initialize zone_builder */
		g_variant_builder_init(&zone_builder, G_VARIANT_TYPE("a{sas}"));

		/* add 'interfaces' and 'sources' */
		g_variant_builder_add(&zone_builder, "{sas}", "interfaces",
				      &ifs_builder);
		g_variant_builder_add(&zone_builder, "{sas}", "sources",
				      &srcs_builder);

		/* add the zone to builder */
		g_variant_builder_add(&builder, "{sa{sas}}", zone_name,
				      &zone_builder);
	    }
	    g_dbus_method_invocation_return_value(invocation,
						  g_variant_new("(a{sa{sas}})",
								&builder));

	} else if (g_strcmp0(method_name, "addInterface") == 0) {
	    gchar *zone, *interface, *use_zone, *return_zone;
	    GError *error = NULL;

	    g_variant_get(parameters, "(&s&s)", &zone, &interface);
	    fwlog_debug1("addInterface('%s', '%s')", zone, interface);

	    use_zone = dbus_check_zone(invocation, zone);
	    if ((size_t) use_zone == -1)
		return;

	    return_zone = fw_add_interface(use_zone, interface);
	    if (return_zone == NULL) {
		g_dbus_method_invocation_return_dbus_error(invocation,
							   DBUS_INTERFACE_ZONE,
							   "ZONE_ALREADY_SET");
		return;
	    }

	    g_dbus_connection_emit_signal(connection, NULL, object_path,
					  interface_name, "InterfaceAdded",
					  g_variant_new("(ss)", return_zone,
							interface),
					  &error);
	    g_assert_no_error(error);
	    fwlog_debug1("InterfaceAdded('%s', '%s')", return_zone, interface);
	    g_dbus_method_invocation_return_value(
		invocation, g_variant_new("(s)", return_zone));

	} else if (g_strcmp0(method_name, "changeZoneOfInterface") == 0 || 
		   g_strcmp0(method_name, "changeZone") == 0) {
	    gchar *zone, *interface, *use_zone, *return_zone;
	    GError *error = NULL;

	    g_variant_get(parameters, "(&s&s)", &zone, &interface);
	    fwlog_debug1("%s('%s', '%s')", method_name, zone, interface);

	    use_zone = dbus_check_zone(invocation, zone);
	    if ((size_t) use_zone == -1)
		return;

	    return_zone = fw_change_zone_of_interface(use_zone, interface);
	    if (return_zone == NULL) {
		g_dbus_method_invocation_return_value(
		    invocation, g_variant_new("(s)", use_zone));
		return;
	    }

	    g_dbus_connection_emit_signal(connection, NULL, object_path,
					  interface_name,
					  "ZoneOfInterfaceChanged",
					  g_variant_new("(ss)", return_zone,
							interface),
					  &error);
	    g_assert_no_error(error);
	    fwlog_debug1("ZoneOfInterfaceChanged('%s', '%s')", return_zone,
			 interface);
	    g_dbus_method_invocation_return_value(
		invocation, g_variant_new("(s)", return_zone));

	} else if (g_strcmp0(method_name, "getZoneOfInterface") == 0) {
	    gchar *interface, *return_zone;

	    g_variant_get(parameters, "(&s)", &interface);
	    fwlog_debug1("getZoneOfInterface('%s')", interface);

	    return_zone = fw_get_zone_of_interface(interface);
	    if (return_zone == NULL)
		return_zone = "";

	    g_dbus_method_invocation_return_value(
		invocation, g_variant_new("(s)", return_zone));

	} else if (g_strcmp0(method_name, "queryInterface") == 0) {
	    gchar *zone, *interface, *use_zone;
	    gboolean bool;

	    g_variant_get(parameters, "(&s&s)", &zone, &interface);
	    fwlog_debug1("queryInterface('%s', '%s')", zone, interface);

	    use_zone = dbus_check_zone(invocation, zone);
	    if ((size_t) use_zone == -1)
		return;

	    bool = fw_query_interface(use_zone, interface);

	    g_dbus_method_invocation_return_value(invocation,
						  g_variant_new("(b)", bool));

        } else if (g_strcmp0(method_name, "removeInterface") == 0) {
            gchar *zone, *interface, *use_zone, *return_zone;
            GError *error = NULL;

            g_variant_get(parameters, "(&s&s)", &zone, &interface);
            fwlog_debug1("removeInterface('%s', '%s')", zone, interface);

	    use_zone = dbus_check_zone(invocation, zone);
	    if ((size_t) use_zone == -1)
		return;

	    return_zone = fw_remove_interface(use_zone, interface);
	    if (return_zone == NULL) {
		g_dbus_method_invocation_return_dbus_error(invocation,
							   DBUS_INTERFACE_ZONE,
							   "ZONE_NOT_SET");
		return;
	    }

            g_dbus_connection_emit_signal(connection, NULL, object_path,
                                          interface_name,
                                          "InterfaceRemoved",
                                          g_variant_new("(ss)", use_zone,
                                                        interface),
                                          &error);
            g_assert_no_error(error);
            fwlog_debug1("InterfaceRemoved('%s', '%s')", use_zone, interface);
            g_dbus_method_invocation_return_value(
		invocation, g_variant_new("(s)", return_zone));

	} else if (g_strcmp0(method_name, "getInterfaces") == 0) {
	    gchar *zone, *use_zone;
	    GVariantBuilder builder;
	    GList *interfaces;
	    int i;

	    g_variant_get(parameters, "(&s)", &zone);
	    fwlog_debug1("getInterfaces('%s')", zone);

	    use_zone = dbus_check_zone(invocation, zone);
	    if ((size_t) use_zone == -1)
		return;

	    interfaces = fw_get_interfaces(use_zone);

	    g_variant_builder_init(&builder, G_VARIANT_TYPE("as"));
	    for (i=0; i<g_list_length(interfaces); i++) {
		g_variant_builder_add(&builder, "s",
				      g_list_nth_data(interfaces, i));
	    }
	    g_dbus_method_invocation_return_value(invocation,
						  g_variant_new("(as)",
								&builder));
        }
    }
}

/* ************************************************************************* */

static GVariant *
dbus_handle_get_property(GDBusConnection *connection,
			 const gchar *sender,
			 const gchar *object_path,
			 const gchar *interface_name,
			 const gchar *property_name,
			 GError **error,
			 gpointer user_data)
{
    GVariant *ret=NULL;
    
    /* g_print("--> handle_get_property(%s, %s, %s, %s)\n", sender, object_path,
       interface_name, property_name); */

    if (g_strcmp0(interface_name, DBUS_INTERFACE) == 0) {
	if (g_strcmp0(property_name, "state") == 0)
	    ret = g_variant_new_string("RUNNING");
	else if (g_strcmp0(property_name, "version") == 0)
	    ret = g_variant_new_string(VERSION);
    } else if (g_strcmp0(interface_name, DBUS_INTERFACE_ZONE) == 0) {
    }

    return ret;
}

/* ************************************************************************* */

static gboolean
dbus_handle_set_property(GDBusConnection *connection,
			 const gchar *sender,
			 const gchar *object_path,
			 const gchar *interface_name,
			 const gchar *property_name,
			 GVariant *value,
			 GError **error,
			 gpointer user_data)
{
    /* g_print("--> handle_set_property(%s, %s, %s, %s)\n", sender, object_path,
       interface_name, property_name); */

    if (g_strcmp0(interface_name, DBUS_INTERFACE) == 0) {

    } else if (g_strcmp0(interface_name, DBUS_INTERFACE_ZONE) == 0) {
    }

    return *error == NULL;
}

/* ************************************************************************* */

static const GDBusInterfaceVTable interface_vtable =
{
    dbus_handle_method_call,
    dbus_handle_get_property,
    dbus_handle_set_property
};

/* ************************************************************************* */

static void
dbus_on_bus_acquired(GDBusConnection *connection,
		     const gchar *name,
		     gpointer user_data)
{
    GDBusNodeInfo *introspection_info;
    GDBusInterfaceInfo *interface_info;
    guint reg_id;

    /* introspection */
    introspection_info = g_dbus_node_info_new_for_xml(introspection_xml, NULL);
    g_assert(introspection_info != NULL);

    /* register interfaces */
    interface_info = g_dbus_node_info_lookup_interface(introspection_info,
						       DBUS_INTERFACE);
    g_assert(interface_info != NULL);
    reg_id = g_dbus_connection_register_object(connection, DBUS_PATH,
					       interface_info,
					       &interface_vtable,
					       NULL, NULL, NULL);
    g_assert(reg_id > 0);

    interface_info = g_dbus_node_info_lookup_interface(introspection_info,
						       DBUS_INTERFACE_ZONE);
    g_assert(interface_info != NULL);
    reg_id = g_dbus_connection_register_object(connection, DBUS_PATH,
					       interface_info,
					       &interface_vtable,
					       NULL, NULL, NULL);
    g_assert(reg_id > 0);


    /* initialize some variables */

    fwlog_debug1("start()");

    if (! fw_start()) {
	fwlog_error("Failed to start.");
	exit(EXIT_FAILURE);
    }
}

/* ************************************************************************* */

static void
dbus_on_name_acquired(GDBusConnection *connection,
		      const gchar     *name,
		      gpointer         user_data)
{
    fwlog_debug10("on_name_acquired(%s)", name);
}

/* ************************************************************************* */

static void
dbus_on_name_lost(GDBusConnection *connection,
		  const gchar *name,
		  gpointer user_data)
{
    fwlog_debug10("on_name_lost(%s)", name);
}

/* ************************************************************************* */

gboolean
dbus_own()
{
    GError *error=NULL;

    /* dbus connection */
    error = NULL;
    connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
    if (connection == NULL) {
	fwlog_error("Failed to connect to system bus: %s",
		  error->message);
	g_error_free(error);
	return FALSE;
    } else {
	gchar *conn_name;
	g_object_get(connection, "unique-name", &conn_name, NULL);
	fwlog_debug2("Connection: '%s'\n", conn_name);
	g_free(conn_name);
    }

    /* do not terminate if remote peer closed connection */
    g_dbus_connection_set_exit_on_close(connection, FALSE);

    /* own name */
    name_id = g_bus_own_name(G_BUS_TYPE_SYSTEM, DBUS_INTERFACE,
			     G_BUS_NAME_OWNER_FLAGS_NONE, dbus_on_bus_acquired,
			     dbus_on_name_acquired, dbus_on_name_lost, NULL,
			     NULL);

    return TRUE;
}

/* ************************************************************************* */

gboolean
dbus_unown()
{
    g_bus_unown_name(name_id);

    return TRUE;
}