/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2016 Atul Anand <atulhjp@gmail.com>.
 */

#include "nm-default.h"

#include "nm-pacrunner-manager.h"

#include "nm-utils.h"
#include "NetworkManagerUtils.h"
#include "platform/nm-platform.h"
#include "nm-dbus-manager.h"
#include "nm-proxy-config.h"
#include "nm-ip4-config.h"
#include "nm-ip6-config.h"
#include "c-list/src/c-list.h"
#include "nm-glib-aux/nm-dbus-aux.h"

#define PACRUNNER_DBUS_SERVICE   "org.pacrunner"
#define PACRUNNER_DBUS_INTERFACE "org.pacrunner.Manager"
#define PACRUNNER_DBUS_PATH      "/org/pacrunner/manager"

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

struct _NMPacrunnerConfId {
    CList conf_id_lst;

    NMPacrunnerManager *self;

    GVariant *parameters;

    char *  path;
    guint64 log_id;
    guint   refcount;
};

typedef struct {
    GDBusConnection *dbus_connection;
    GCancellable *   cancellable;
    CList            conf_id_lst_head;
    guint64          log_id_counter;
    guint            name_owner_changed_id;
    bool             dbus_initied : 1;
    bool             has_name_owner : 1;
    bool             try_start_blocked : 1;
} NMPacrunnerManagerPrivate;

struct _NMPacrunnerManager {
    GObject                   parent;
    NMPacrunnerManagerPrivate _priv;
};

struct _NMPacrunnerManagerClass {
    GObjectClass parent;
};

G_DEFINE_TYPE(NMPacrunnerManager, nm_pacrunner_manager, G_TYPE_OBJECT)

#define NM_PACRUNNER_MANAGER_GET_PRIVATE(self) \
    _NM_GET_PRIVATE(self, NMPacrunnerManager, NM_IS_PACRUNNER_MANAGER)

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

NM_DEFINE_SINGLETON_GETTER(NMPacrunnerManager, nm_pacrunner_manager_get, NM_TYPE_PACRUNNER_MANAGER);

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

#define _NMLOG_DOMAIN      LOGD_PROXY
#define _NMLOG(level, ...) __NMLOG_DEFAULT(level, _NMLOG_DOMAIN, "pacrunner", __VA_ARGS__)

#define _NMLOG2_PREFIX_NAME "pacrunner"
#define _NMLOG2(level, conf_id, ...)                                            \
    G_STMT_START                                                                \
    {                                                                           \
        nm_log((level),                                                         \
               _NMLOG_DOMAIN,                                                   \
               NULL,                                                            \
               NULL,                                                            \
               "%s%" G_GUINT64_FORMAT "]: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__), \
               _NMLOG2_PREFIX_NAME ": call[",                                   \
               (conf_id)->log_id _NM_UTILS_MACRO_REST(__VA_ARGS__));            \
    }                                                                           \
    G_STMT_END

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

static void _call_destroy_proxy_configuration(NMPacrunnerManager *self,
                                              NMPacrunnerConfId * conf_id,
                                              const char *        path,
                                              gboolean            verbose_log);

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

static NMPacrunnerConfId *
conf_id_ref(NMPacrunnerConfId *conf_id)
{
    nm_assert(conf_id);
    nm_assert(conf_id->refcount > 0);

    conf_id->refcount++;
    return conf_id;
}

static void
conf_id_unref(NMPacrunnerConfId *conf_id)
{
    nm_assert(conf_id);
    nm_assert(conf_id->refcount > 0);

    if (conf_id->refcount == 1) {
        g_variant_unref(conf_id->parameters);
        g_free(conf_id->path);
        c_list_unlink_stale(&conf_id->conf_id_lst);
        g_object_unref(conf_id->self);
        g_slice_free(NMPacrunnerConfId, conf_id);
    } else
        conf_id->refcount--;
}

NM_AUTO_DEFINE_FCN0(NMPacrunnerConfId *, _nm_auto_unref_conf_id, conf_id_unref);
#define nm_auto_unref_conf_id nm_auto(_nm_auto_unref_conf_id)

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

static void
get_ip_domains(GPtrArray *domains, NMIPConfig *ip_config)
{
    NMDedupMultiIter           ipconf_iter;
    char *                     cidr;
    guint                      i, num;
    char                       sbuf[NM_UTILS_INET_ADDRSTRLEN];
    int                        addr_family;
    const NMPlatformIPAddress *address;
    const NMPlatformIPRoute *  routes;

    if (!ip_config)
        return;

    addr_family = nm_ip_config_get_addr_family(ip_config);

    num = nm_ip_config_get_num_searches(ip_config);
    for (i = 0; i < num; i++)
        g_ptr_array_add(domains, g_strdup(nm_ip_config_get_search(ip_config, i)));

    num = nm_ip_config_get_num_domains(ip_config);
    for (i = 0; i < num; i++)
        g_ptr_array_add(domains, g_strdup(nm_ip_config_get_domain(ip_config, i)));

    nm_ip_config_iter_ip_address_for_each (&ipconf_iter, ip_config, &address) {
        cidr = g_strdup_printf("%s/%u",
                               nm_utils_inet_ntop(addr_family, address->address_ptr, sbuf),
                               address->plen);
        g_ptr_array_add(domains, cidr);
    }

    nm_ip_config_iter_ip_route_for_each (&ipconf_iter, ip_config, &routes) {
        if (NM_PLATFORM_IP_ROUTE_IS_DEFAULT(routes))
            continue;
        cidr = g_strdup_printf("%s/%u",
                               nm_utils_inet_ntop(addr_family, routes->network_ptr, sbuf),
                               routes->plen);
        g_ptr_array_add(domains, cidr);
    }
}

static GVariant *
_make_request_create_proxy_configuration(NMProxyConfig *proxy_config,
                                         const char *   iface,
                                         NMIP4Config *  ip4_config,
                                         NMIP6Config *  ip6_config)
{
    GVariantBuilder     builder;
    NMProxyConfigMethod method;
    const char *        pac_url;
    const char *        pac_script;

    nm_assert(NM_IS_PROXY_CONFIG(proxy_config));

    g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);

    if (iface) {
        g_variant_builder_add(&builder, "{sv}", "Interface", g_variant_new_string(iface));
    }

    method = nm_proxy_config_get_method(proxy_config);
    switch (method) {
    case NM_PROXY_CONFIG_METHOD_AUTO:
        g_variant_builder_add(&builder, "{sv}", "Method", g_variant_new_string("auto"));

        pac_url = nm_proxy_config_get_pac_url(proxy_config);
        if (pac_url) {
            g_variant_builder_add(&builder, "{sv}", "URL", g_variant_new_string(pac_url));
        }

        pac_script = nm_proxy_config_get_pac_script(proxy_config);
        if (pac_script) {
            g_variant_builder_add(&builder, "{sv}", "Script", g_variant_new_string(pac_script));
        }
        break;
    case NM_PROXY_CONFIG_METHOD_NONE:
        g_variant_builder_add(&builder, "{sv}", "Method", g_variant_new_string("direct"));
        break;
    }

    g_variant_builder_add(&builder,
                          "{sv}",
                          "BrowserOnly",
                          g_variant_new_boolean(nm_proxy_config_get_browser_only(proxy_config)));

    if (ip4_config || ip6_config) {
        gs_unref_ptrarray GPtrArray *domains = NULL;

        domains = g_ptr_array_new_with_free_func(g_free);

        get_ip_domains(domains, NM_IP_CONFIG_CAST(ip4_config));
        get_ip_domains(domains, NM_IP_CONFIG_CAST(ip6_config));

        if (domains->len > 0) {
            g_variant_builder_add(
                &builder,
                "{sv}",
                "Domains",
                g_variant_new_strv((const char *const *) domains->pdata, domains->len));
        }
    }

    return g_variant_new("(a{sv})", &builder);
}

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

static void
_call_destroy_proxy_configuration_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
    nm_auto_unref_conf_id NMPacrunnerConfId *conf_id = user_data;
    gs_free_error GError *error                      = NULL;
    gs_unref_variant GVariant *ret                   = NULL;

    ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), res, &error);
    if (!ret) {
        if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
            _LOG2T(conf_id, "destroy proxy configuration: failed with %s", error->message);
        else
            _LOG2T(conf_id, "destroy proxy configuration: cancelled");
        return;
    }
    _LOG2T(conf_id, "destroy proxy configuration: success");
}

static void
_call_create_proxy_configuration_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
    nm_auto_unref_conf_id NMPacrunnerConfId *conf_id = user_data;
    NMPacrunnerManager *                     self    = NM_PACRUNNER_MANAGER(conf_id->self);
    gs_free_error GError *error                      = NULL;
    gs_unref_variant GVariant *variant               = NULL;
    const char *               path                  = NULL;

    nm_assert(!conf_id->path);

    variant = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), res, &error);

    if (!variant) {
        if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
            _LOG2T(conf_id, "create proxy configuration failed: %s", error->message);
        else
            _LOG2T(conf_id, "create proxy configuration cancelled");
        return;
    }

    g_variant_get(variant, "(&o)", &path);

    if (c_list_is_empty(&conf_id->conf_id_lst)) {
        _LOG2T(conf_id,
               "create proxy configuration succeeded (%s), but destroy it right away",
               path);
        _call_destroy_proxy_configuration(self, conf_id, path, FALSE);
    } else {
        _LOG2T(conf_id, "create proxy configuration succeeded (%s)", path);
        conf_id->path = g_strdup(path);
    }
}

static void
_call_destroy_proxy_configuration(NMPacrunnerManager *self,
                                  NMPacrunnerConfId * conf_id,
                                  const char *        path,
                                  gboolean            verbose_log)
{
    NMPacrunnerManagerPrivate *priv = NM_PACRUNNER_MANAGER_GET_PRIVATE(self);

    if (verbose_log)
        _LOG2T(conf_id, "destroy proxy configuration %s...", path);

    g_dbus_connection_call(priv->dbus_connection,
                           PACRUNNER_DBUS_SERVICE,
                           PACRUNNER_DBUS_PATH,
                           PACRUNNER_DBUS_INTERFACE,
                           "DestroyProxyConfiguration",
                           g_variant_new("(o)", path),
                           G_VARIANT_TYPE("()"),
                           G_DBUS_CALL_FLAGS_NO_AUTO_START,
                           NM_SHUTDOWN_TIMEOUT_MS,
                           priv->cancellable,
                           _call_destroy_proxy_configuration_cb,
                           conf_id_ref(conf_id));
}

static void
_call_create_proxy_configuration(NMPacrunnerManager *self,
                                 NMPacrunnerConfId * conf_id,
                                 gboolean            verbose_log)
{
    NMPacrunnerManagerPrivate *priv = NM_PACRUNNER_MANAGER_GET_PRIVATE(self);

    if (verbose_log)
        _LOG2T(conf_id, "create proxy configuration...");

    g_dbus_connection_call(priv->dbus_connection,
                           PACRUNNER_DBUS_SERVICE,
                           PACRUNNER_DBUS_PATH,
                           PACRUNNER_DBUS_INTERFACE,
                           "CreateProxyConfiguration",
                           conf_id->parameters,
                           G_VARIANT_TYPE("(o)"),
                           G_DBUS_CALL_FLAGS_NO_AUTO_START,
                           NM_SHUTDOWN_TIMEOUT_MS,
                           priv->cancellable,
                           _call_create_proxy_configuration_cb,
                           conf_id_ref(conf_id));
}

static gboolean
_try_start_service_by_name(NMPacrunnerManager *self)
{
    NMPacrunnerManagerPrivate *priv = NM_PACRUNNER_MANAGER_GET_PRIVATE(self);

    if (priv->try_start_blocked || !priv->dbus_initied)
        return FALSE;

    _LOGD("try D-Bus activating pacrunner...");
    priv->try_start_blocked = TRUE;
    nm_dbus_connection_call_start_service_by_name(priv->dbus_connection,
                                                  PACRUNNER_DBUS_SERVICE,
                                                  -1,
                                                  NULL,
                                                  NULL,
                                                  NULL);
    return TRUE;
}

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

/**
 * nm_pacrunner_manager_add:
 * @self: the #NMPacrunnerManager
 * @proxy_config: proxy config of the connection
 * @iface: the iface for the connection or %NULL
 * @ip4_config: IP4 config of the connection to extract domain info from
 * @ip6_config: IP6 config of the connection to extract domain info from
 *
 * Returns: a #NMPacrunnerConfId id. The function cannot
 *  fail and always returns a non NULL pointer. The conf-id may
 *  be used to remove the configuration later via nm_pacrunner_manager_remove().
 *  Note that the conf-id keeps the @self instance alive.
 */
NMPacrunnerConfId *
nm_pacrunner_manager_add(NMPacrunnerManager *self,
                         NMProxyConfig *     proxy_config,
                         const char *        iface,
                         NMIP4Config *       ip4_config,
                         NMIP6Config *       ip6_config)
{
    NMPacrunnerManagerPrivate *priv;
    NMPacrunnerConfId *        conf_id;
    gs_free char *             log_msg = NULL;

    g_return_val_if_fail(NM_IS_PACRUNNER_MANAGER(self), NULL);
    g_return_val_if_fail(proxy_config, NULL);

    priv = NM_PACRUNNER_MANAGER_GET_PRIVATE(self);

    conf_id  = g_slice_new(NMPacrunnerConfId);
    *conf_id = (NMPacrunnerConfId){
        .log_id     = ++priv->log_id_counter,
        .refcount   = 1,
        .self       = g_object_ref(self),
        .parameters = g_variant_ref_sink(
            _make_request_create_proxy_configuration(proxy_config, iface, ip4_config, ip6_config)),
    };
    c_list_link_tail(&priv->conf_id_lst_head, &conf_id->conf_id_lst);

    if (!priv->has_name_owner) {
        _LOG2T(conf_id,
               "add config: %s (%s)",
               (log_msg = g_variant_print(conf_id->parameters, FALSE)),
               "pacrunner D-Bus service not running");
        _try_start_service_by_name(self);
    } else {
        _LOG2T(conf_id,
               "add config: %s (%s)",
               (log_msg = g_variant_print(conf_id->parameters, FALSE)),
               "create proxy configuration");
        _call_create_proxy_configuration(self, conf_id, FALSE);
    }

    return conf_id;
}

/**
 * nm_pacrunner_manager_remove:
 * @conf_id: the conf id obtained from nm_pacrunner_manager_add()
 */
void
nm_pacrunner_manager_remove(NMPacrunnerConfId *conf_id)
{
    _nm_unused nm_auto_unref_conf_id NMPacrunnerConfId *conf_id_free = conf_id;
    NMPacrunnerManager *                                self;
    NMPacrunnerManagerPrivate *                         priv;

    g_return_if_fail(conf_id);

    self = conf_id->self;

    g_return_if_fail(NM_IS_PACRUNNER_MANAGER(self));

    priv = NM_PACRUNNER_MANAGER_GET_PRIVATE(self);

    _LOG2T(conf_id, "removing...");

    nm_assert(c_list_contains(&priv->conf_id_lst_head, &conf_id->conf_id_lst));

    c_list_unlink(&conf_id->conf_id_lst);

    if (!conf_id->path) {
        /* There is no ID to destroy the configuration.
         *
         * That can happen because:
         *
         *  - pacrunner D-Bus service is not running (no name owner) and we didn't call CreateProxyConfiguration.
         *  - CreateProxyConfiguration failed.
         *  - CreateProxyConfiguration is in progress.
         *
         * In all cases there is nothing to do. Note that if CreateProxyConfiguration is in progress
         * it has a reference on the conf-id and it will automatically destroy the configuration
         * when it completes.
         */
        return;
    }

    _call_destroy_proxy_configuration(self, conf_id, conf_id->path, TRUE);
}

gboolean
nm_pacrunner_manager_remove_clear(NMPacrunnerConfId **p_conf_id)
{
    g_return_val_if_fail(p_conf_id, FALSE);

    if (!*p_conf_id)
        return FALSE;
    nm_pacrunner_manager_remove(g_steal_pointer(p_conf_id));
    return TRUE;
}

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

static void
name_owner_changed(NMPacrunnerManager *self, const char *name_owner)
{
    NMPacrunnerManagerPrivate *priv = NM_PACRUNNER_MANAGER_GET_PRIVATE(self);
    NMPacrunnerConfId *        conf_id;
    gboolean                   has_name_owner;

    has_name_owner = (name_owner && name_owner[0]);

    if (priv->dbus_initied && priv->has_name_owner == has_name_owner)
        return;

    priv->has_name_owner = has_name_owner;

    nm_clear_g_cancellable(&priv->cancellable);

    if (has_name_owner) {
        priv->dbus_initied      = TRUE;
        priv->try_start_blocked = FALSE;
        _LOGD("pacrunner appeared on D-Bus (%s)", name_owner);
        priv->cancellable = g_cancellable_new();
        c_list_for_each_entry (conf_id, &priv->conf_id_lst_head, conf_id_lst)
            _call_create_proxy_configuration(self, conf_id, TRUE);
    } else {
        if (!priv->dbus_initied) {
            priv->dbus_initied = TRUE;
            nm_assert(!priv->try_start_blocked);
            _LOGD("pacrunner not on D-Bus");
        } else
            _LOGD("pacrunner disappeared from D-Bus");
        if (!c_list_is_empty(&priv->conf_id_lst_head)) {
            c_list_for_each_entry (conf_id, &priv->conf_id_lst_head, conf_id_lst)
                nm_clear_g_free(&conf_id->path);
            _try_start_service_by_name(self);
        }
    }
}

static void
name_owner_changed_cb(GDBusConnection *connection,
                      const char *     sender_name,
                      const char *     object_path,
                      const char *     interface_name,
                      const char *     signal_name,
                      GVariant *       parameters,
                      gpointer         user_data)
{
    const char *new_owner;

    if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(sss)")))
        return;

    g_variant_get(parameters, "(&s&s&s)", NULL, NULL, &new_owner);

    name_owner_changed(user_data, new_owner);
}

static void
get_name_owner_cb(const char *name_owner, GError *error, gpointer user_data)
{
    if (!name_owner && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        return;

    name_owner_changed(user_data, name_owner);
}

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

static void
nm_pacrunner_manager_init(NMPacrunnerManager *self)
{
    NMPacrunnerManagerPrivate *priv = NM_PACRUNNER_MANAGER_GET_PRIVATE(self);

    c_list_init(&priv->conf_id_lst_head);

    priv->dbus_connection = nm_g_object_ref(NM_MAIN_DBUS_CONNECTION_GET);

    if (!priv->dbus_connection) {
        _LOGD("no D-Bus connection to talk to pacrunner");
        return;
    }

    priv->name_owner_changed_id =
        nm_dbus_connection_signal_subscribe_name_owner_changed(priv->dbus_connection,
                                                               PACRUNNER_DBUS_SERVICE,
                                                               name_owner_changed_cb,
                                                               self,
                                                               NULL);
    priv->cancellable = g_cancellable_new();

    nm_dbus_connection_call_get_name_owner(priv->dbus_connection,
                                           PACRUNNER_DBUS_SERVICE,
                                           -1,
                                           priv->cancellable,
                                           get_name_owner_cb,
                                           self);
}

static void
dispose(GObject *object)
{
    NMPacrunnerManagerPrivate *priv = NM_PACRUNNER_MANAGER_GET_PRIVATE(object);

    nm_assert(c_list_is_empty(&priv->conf_id_lst_head));

    /* we cancel all pending operations. Note that pacrunner automatically
     * removes all configuration once NetworkManager disconnects from
     * the bus -- which happens soon after we destroy the pacrunner manager.
     */
    nm_clear_g_cancellable(&priv->cancellable);

    nm_clear_g_dbus_connection_signal(priv->dbus_connection, &priv->name_owner_changed_id);
    g_clear_object(&priv->dbus_connection);

    G_OBJECT_CLASS(nm_pacrunner_manager_parent_class)->dispose(object);
}

static void
nm_pacrunner_manager_class_init(NMPacrunnerManagerClass *klass)
{
    GObjectClass *object_class = G_OBJECT_CLASS(klass);

    object_class->dispose = dispose;
}