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

}