/* SPDX-License-Identifier: GPL-2.0+ */

/*

 * Copyright (C) 2013 Red Hat, Inc.

 */

/**

 * SECTION:nm-editor-bindings

 * @short_description: #GBinding-based NM connection editor helpers

 *

 * nm-editor-bindings contains helper functions to bind NMSettings objects

 * to connection editing widgets. The goal is that this should eventually be

 * shared between nmtui, nm-connection-editor, and gnome-control-center.

 */

#include "nm-default.h"

#include "nm-editor-bindings.h"

#include <arpa/inet.h>

#include <netinet/in.h>

#include <stdlib.h>

static void

value_transform_string_int(const GValue *src_value, GValue *dest_value)

{

    long  val;

    char *end;

    val = strtol(g_value_get_string(src_value), &end, 10);

    if (val < G_MININT || val > G_MAXINT || *end)

        return;

    g_value_set_int(dest_value, (int) val);

}

static void

value_transform_string_uint(const GValue *src_value, GValue *dest_value)

{

    long  val;

    char *end;

    val = strtol(g_value_get_string(src_value), &end, 10);

    if (val < 0 || val > G_MAXUINT || *end)

        return;

    g_value_set_uint(dest_value, (int) val);

}

void

nm_editor_bindings_init(void)

{

    /* glib registers number -> string, but not string -> number */

    g_value_register_transform_func(G_TYPE_STRING, G_TYPE_INT, value_transform_string_int);

    g_value_register_transform_func(G_TYPE_STRING, G_TYPE_UINT, value_transform_string_uint);

}

static gboolean

ip_addresses_with_prefix_to_strv(GBinding *    binding,

                                 const GValue *source_value,

                                 GValue *      target_value,

                                 gpointer      user_data)

{

    GPtrArray *  addrs;

    NMIPAddress *addr;

    const char * addrstr;

    guint32      prefix;

    char **      strings;

    int          i;

    addrs   = g_value_get_boxed(source_value);

    strings = g_new0(char *, addrs->len + 1);

    for (i = 0; i < addrs->len; i++) {

        addr    = addrs->pdata[i];

        addrstr = nm_ip_address_get_address(addr);

        prefix  = nm_ip_address_get_prefix(addr);

        if (addrstr)

            strings[i] = g_strdup_printf("%s/%d", addrstr, (int) prefix);

        else

            strings[i] = g_strdup("");

    }

    g_value_take_boxed(target_value, strings);

    return TRUE;

}

static gboolean

ip_addresses_with_prefix_from_strv(GBinding *    binding,

                                   const GValue *source_value,

                                   GValue *      target_value,

                                   gpointer      user_data)

{

    int          addr_family = GPOINTER_TO_INT(user_data);

    char **      strings;

    GPtrArray *  addrs;

    NMIPAddress *addr;

    char *       addrstr;

    int          prefix;

    int          i;

    strings = g_value_get_boxed(source_value);

    /* Fetch the original property value, so as to preserve their extra attributes */

    g_object_get(g_binding_get_source(binding),

                 g_binding_get_source_property(binding),

                 &addrs,

                 NULL);

    for (i = 0; strings[i]; i++) {

        if (i >= addrs->len) {

            if (addr_family == AF_INET)

                addr = nm_ip_address_new(AF_INET, "0.0.0.0", 32, NULL);

            else

                addr = nm_ip_address_new(AF_INET6, "::", 128, NULL);

            g_ptr_array_add(addrs, addr);

        } else

            addr = addrs->pdata[i];

        if (!nm_utils_parse_inaddr_prefix(addr_family, strings[i], &addrstr, &prefix)) {

            g_ptr_array_unref(addrs);

            return FALSE;

        }

        if (prefix == -1) {

            if (addr_family == AF_INET) {

                in_addr_t v4;

                inet_pton(addr_family, addrstr, &v4;;

                if (nm_utils_ip_is_site_local(AF_INET, &v4))

                    prefix = nm_utils_ip4_get_default_prefix(v4);

                else

                    prefix = 32;

            } else

                prefix = 64;

        }

        nm_ip_address_set_address(addr, addrstr);

        nm_ip_address_set_prefix(addr, prefix);

        g_free(addrstr);

    }

    g_ptr_array_set_size(addrs, i);

    g_value_take_boxed(target_value, addrs);

    return TRUE;

}

/**

 * nm_editor_bind_ip_addresses_with_prefix_to_strv:

 * @addr_family: the IP address family

 * @source: the source object (eg, an #NMSettingIP4Config)

 * @source_property: the property on @source to bind (eg,

 *   %NM_SETTING_IP4_CONFIG_ADDRESSES)

 * @target: the target object (eg, an #NmtAddressList)

 * @target_property: the property on @target to bind

 *   (eg, "strings")

 * @flags: %GBindingFlags

 *

 * Binds the #GPtrArray-of-#NMIPAddress property @source_property on @source to

 * the %G_TYPE_STRV property @target_property on @target.

 *

 * Each #NMIPAddress in @source_property will be converted to a string of the

 * form "ip.ad.dr.ess/prefix" or "ip:ad:dr:ess/prefix" in @target_property (and

 * vice versa if %G_BINDING_BIDIRECTIONAL) is specified.

 */

void

nm_editor_bind_ip_addresses_with_prefix_to_strv(int           addr_family,

                                                gpointer      source,

                                                const char *  source_property,

                                                gpointer      target,

                                                const char *  target_property,

                                                GBindingFlags flags)

{

    g_object_bind_property_full(source,

                                source_property,

                                target,

                                target_property,

                                flags,

                                ip_addresses_with_prefix_to_strv,

                                ip_addresses_with_prefix_from_strv,

                                GINT_TO_POINTER(addr_family),

                                NULL);

}

static gboolean

ip_addresses_check_and_copy(GBinding *    binding,

                            const GValue *source_value,

                            GValue *      target_value,

                            gpointer      user_data)

{

    int    addr_family = GPOINTER_TO_INT(user_data);

    char **strings;

    int    i;

    strings = g_value_get_boxed(source_value);

    for (i = 0; strings[i]; i++) {

        if (!nm_utils_ipaddr_is_valid(addr_family, strings[i]))

            return FALSE;

    }

    g_value_set_boxed(target_value, strings);

    return TRUE;

}

/**

 * nm_editor_bind_ip_addresses_to_strv:

 * @addr_family: the IP address family

 * @source: the source object (eg, an #NMSettingIP4Config)

 * @source_property: the property on @source to bind (eg,

 *   %NM_SETTING_IP4_CONFIG_DNS)

 * @target: the target object (eg, an #NmtAddressList)

 * @target_property: the property on @target to bind

 *   (eg, "strings")

 * @flags: %GBindingFlags

 *

 * Binds the %G_TYPE_STRV property @source_property on @source to the

 * %G_TYPE_STRV property @target_property on @target, verifying that

 * each string is a valid address of type @addr_family when copying.

 */

void

nm_editor_bind_ip_addresses_to_strv(int           addr_family,

                                    gpointer      source,

                                    const char *  source_property,

                                    gpointer      target,

                                    const char *  target_property,

                                    GBindingFlags flags)

{

    g_object_bind_property_full(source,

                                source_property,

                                target,

                                target_property,

                                flags,

                                ip_addresses_check_and_copy,

                                ip_addresses_check_and_copy,

                                GINT_TO_POINTER(addr_family),

                                NULL);

}

static gboolean

ip_gateway_to_string(GBinding *    binding,

                     const GValue *source_value,

                     GValue *      target_value,

                     gpointer      user_data)

{

    g_value_set_string(target_value, g_value_get_string(source_value));

    return TRUE;

}

static gboolean

ip_gateway_from_string(GBinding *    binding,

                       const GValue *source_value,

                       GValue *      target_value,

                       gpointer      user_data)

{

    int         addr_family = GPOINTER_TO_INT(user_data);

    const char *gateway;

    gateway = g_value_get_string(source_value);

    if (gateway && !nm_utils_ipaddr_is_valid(addr_family, gateway))

        gateway = NULL;

    g_value_set_string(target_value, gateway);

    return TRUE;

}

static gboolean

ip_addresses_to_gateway(GBinding *    binding,

                        const GValue *source_value,

                        GValue *      target_value,

                        gpointer      user_data)

{

    GPtrArray *addrs;

    addrs = g_value_get_boxed(source_value);

    if (addrs->len == 0) {

        g_value_set_string(target_value, NULL);

        return TRUE;

    } else

        return FALSE;

}

static gboolean

ip_addresses_to_sensitivity(GBinding *    binding,

                            const GValue *source_value,

                            GValue *      target_value,

                            gpointer      user_data)

{

    GPtrArray *addrs;

    addrs = g_value_get_boxed(source_value);

    g_value_set_boolean(target_value, addrs->len != 0);

    return TRUE;

}

/**

 * nm_editor_bind_ip_gateway_to_string:

 * @addr_family: the IP address family

 * @source: the source #NMSettingIPConfig

 * @target: the target object (eg, an #NmtIPEntry)

 * @target_property: the property on @target to bind (eg, "text")

 * @target_sensitive_property: the "sensitivity" property on @target to bind

 * @flags: %GBindingFlags

 *

 * Binds the #NMSettingIPConfig:gateway property on @source to the

 * %G_TYPE_STRING property @target_property and %G_TYPE_BOOLEAN property

 * @target_sensitive_property on @target, also taking the

 * #NMSettingIPConfig:addresses property on @source into account.

 *

 * In particular, if @source has no static IP addresses, then @target_property

 * will be set to "" and @target_sensitive_property will be set to %FALSE.

 *

 * If @source has at least one static IP address, then

 * @target_sensitive_property will be set to %TRUE, @target_property will be

 * initialized from @source's #NMSettingIPConfig:gateway, and @source will be

 * updated with the value of @target_property whenever it contains a valid IP

 * address.

 */

void

nm_editor_bind_ip_gateway_to_string(int                addr_family,

                                    NMSettingIPConfig *source,

                                    gpointer           target,

                                    const char *       target_property,

                                    const char *       target_sensitive_property,

                                    GBindingFlags      flags)

{

    g_object_bind_property_full(source,

                                "gateway",

                                target,

                                target_property,

                                flags,

                                ip_gateway_to_string,

                                ip_gateway_from_string,

                                GINT_TO_POINTER(addr_family),

                                NULL);

    g_object_bind_property_full(source,

                                "addresses",

                                source,

                                "gateway",

                                (flags & G_BINDING_SYNC_CREATE),

                                ip_addresses_to_gateway,

                                NULL,

                                NULL,

                                NULL);

    g_object_bind_property_full(source,

                                "addresses",

                                target,

                                target_sensitive_property,

                                (flags & G_BINDING_SYNC_CREATE),

                                ip_addresses_to_sensitivity,

                                NULL,

                                NULL,

                                NULL);

}

static gboolean

ip_route_transform_to_dest_string(GBinding *    binding,

                                  const GValue *source_value,

                                  GValue *      target_value,

                                  gpointer      user_data)

{

    NMIPRoute * route;

    const char *addrstr;

    char *      string;

    route = g_value_get_boxed(source_value);

    if (route)

        addrstr = nm_ip_route_get_dest(route);

    else

        addrstr = NULL;

    if (addrstr) {

        string = g_strdup_printf("%s/%d", addrstr, (int) nm_ip_route_get_prefix(route));

        g_value_take_string(target_value, string);

    } else

        g_value_set_string(target_value, "");

    return TRUE;

}

static gboolean

ip_route_transform_to_next_hop_string(GBinding *    binding,

                                      const GValue *source_value,

                                      GValue *      target_value,

                                      gpointer      user_data)

{

    NMIPRoute * route;

    const char *addrstr;

    route = g_value_get_boxed(source_value);

    if (route) {

        addrstr = nm_ip_route_get_next_hop(route);

        if (!addrstr)

            addrstr = "";

    } else

        addrstr = "";

    g_value_set_string(target_value, addrstr);

    return TRUE;

}

static gboolean

ip_route_transform_to_metric_string(GBinding *    binding,

                                    const GValue *source_value,

                                    GValue *      target_value,

                                    gpointer      user_data)

{

    NMIPRoute *route;

    char *     string;

    route = g_value_get_boxed(source_value);

    if (route && nm_ip_route_get_dest(route) && nm_ip_route_get_metric(route) != -1) {

        string = g_strdup_printf("%lu", (gulong) nm_ip_route_get_metric(route));

        g_value_take_string(target_value, string);

    } else

        g_value_set_string(target_value, "");

    return TRUE;

}

static gboolean

ip_route_transform_from_dest_string(GBinding *    binding,

                                    const GValue *source_value,

                                    GValue *      target_value,

                                    gpointer      user_data)

{

    int         addr_family = GPOINTER_TO_INT(user_data);

    NMIPRoute * route;

    const char *text;

    char *      addrstr;

    int         prefix;

    text = g_value_get_string(source_value);

    if (!nm_utils_parse_inaddr_prefix(addr_family, text, &addrstr, &prefix))

        return FALSE;

    /* Fetch the original property value */

    g_object_get(g_binding_get_source(binding),

                 g_binding_get_source_property(binding),

                 &route,

                 NULL);

    if (prefix == -1) {

        if (addr_family == AF_INET) {

            in_addr_t v4;

            inet_pton(addr_family, addrstr, &v4;;

            if (nm_utils_ip_is_site_local(AF_INET, &v4)) {

                prefix = nm_utils_ip4_get_default_prefix(v4);

                if (v4 & (~nm_utils_ip4_prefix_to_netmask(prefix)))

                    prefix = 32;

            } else

                prefix = 32;

        } else

            prefix = 64;

    }

    nm_ip_route_set_dest(route, addrstr);

    nm_ip_route_set_prefix(route, prefix);

    g_free(addrstr);

    g_value_take_boxed(target_value, route);

    return TRUE;

}

static gboolean

ip_route_transform_from_next_hop_string(GBinding *    binding,

                                        const GValue *source_value,

                                        GValue *      target_value,

                                        gpointer      user_data)

{

    int         addr_family = GPOINTER_TO_INT(user_data);

    NMIPRoute * route;

    const char *text;

    text = g_value_get_string(source_value);

    if (*text) {

        if (!nm_utils_ipaddr_is_valid(addr_family, text))

            return FALSE;

    } else

        text = NULL;

    /* Fetch the original property value */

    g_object_get(g_binding_get_source(binding),

                 g_binding_get_source_property(binding),

                 &route,

                 NULL);

    nm_ip_route_set_next_hop(route, text);

    g_value_take_boxed(target_value, route);

    return TRUE;

}

static gboolean

ip_route_transform_from_metric_string(GBinding *    binding,

                                      const GValue *source_value,

                                      GValue *      target_value,

                                      gpointer      user_data)

{

    NMIPRoute * route;

    const char *text;

    gint64      metric;

    text   = g_value_get_string(source_value);

    metric = _nm_utils_ascii_str_to_int64(text, 10, 0, G_MAXUINT32, -1);

    /* Fetch the original property value */

    g_object_get(g_binding_get_source(binding),

                 g_binding_get_source_property(binding),

                 &route,

                 NULL);

    nm_ip_route_set_metric(route, metric);

    g_value_take_boxed(target_value, route);

    return TRUE;

}

/**

 * nm_editor_bind_ip_route_to_strings:

 * @addr_family: the IP address family

 * @source: the source object

 * @source_property: the source property

 * @dest_target: the target object for the route's destination

 * @dest_target_property: the property on @dest_target

 * @next_hop_target: the target object for the route's next hop

 * @next_hop_target_property: the property on @next_hop_target

 * @metric_target: the target object for the route's metric

 * @metric_target_property: the property on @metric_target

 * @flags: %GBindingFlags

 *

 * Binds the #NMIPRoute-valued property @source_property on @source to the

 * three indicated string-valued target properties (and vice versa if

 * %G_BINDING_BIDIRECTIONAL is specified).

 *

 * @dest_target_property should be an "address/prefix" string, as with

 * nm_editor_bind_ip4_addresses_with_prefix_to_strv(). @next_hop_target_property

 * is a plain IP address, and @metric_target_property is a number.

 */

void

nm_editor_bind_ip_route_to_strings(int           addr_family,

                                   gpointer      source,

                                   const char *  source_property,

                                   gpointer      dest_target,

                                   const char *  dest_target_property,

                                   gpointer      next_hop_target,

                                   const char *  next_hop_target_property,

                                   gpointer      metric_target,

                                   const char *  metric_target_property,

                                   GBindingFlags flags)

{

    g_object_bind_property_full(source,

                                source_property,

                                dest_target,

                                dest_target_property,

                                flags,

                                ip_route_transform_to_dest_string,

                                ip_route_transform_from_dest_string,

                                GINT_TO_POINTER(addr_family),

                                NULL);

    g_object_bind_property_full(source,

                                source_property,

                                next_hop_target,

                                next_hop_target_property,

                                flags,

                                ip_route_transform_to_next_hop_string,

                                ip_route_transform_from_next_hop_string,

                                GINT_TO_POINTER(addr_family),

                                NULL);

    g_object_bind_property_full(source,

                                source_property,

                                metric_target,

                                metric_target_property,

                                flags,

                                ip_route_transform_to_metric_string,

                                ip_route_transform_from_metric_string,

                                GINT_TO_POINTER(addr_family),

                                NULL);

}

/* Wireless security method binding */

typedef struct {

    NMConnection *             connection;

    NMSettingWirelessSecurity *s_wsec;

    gboolean                   s_wsec_in_use;

    GObject *target;

    char *   target_property;

    gboolean updating;

} NMEditorWirelessSecurityMethodBinding;

static const char *

get_security_type(NMEditorWirelessSecurityMethodBinding *binding)

{

    const char *key_mgmt, *auth_alg;

    if (!binding->s_wsec_in_use)

        return "none";

    key_mgmt = nm_setting_wireless_security_get_key_mgmt(binding->s_wsec);

    auth_alg = nm_setting_wireless_security_get_auth_alg(binding->s_wsec);

    /* No IEEE 802.1x */

    if (!strcmp(key_mgmt, "none")) {

        NMWepKeyType wep_type = nm_setting_wireless_security_get_wep_key_type(binding->s_wsec);

        if (wep_type == NM_WEP_KEY_TYPE_KEY)

            return "wep-key";

        else

            return "wep-passphrase";

    }

    if (!strcmp(key_mgmt, "ieee8021x")) {

        if (auth_alg && !strcmp(auth_alg, "leap"))

            return "leap";

        return "dynamic-wep";

    }

    if (!strcmp(key_mgmt, "wpa-psk"))

        return "wpa-personal";

    if (!strcmp(key_mgmt, "sae"))

        return "wpa3-personal";

    if (!strcmp(key_mgmt, "owe"))

        return "owe";

    if (!strcmp(key_mgmt, "wpa-eap"))

        return "wpa-enterprise";

    if (!strcmp(key_mgmt, "wpa-eap-suite-b-192"))

        return "wpa3-enterprise-suite-b-192";

    return NULL;

}

static void

wireless_security_changed(GObject *object, GParamSpec *pspec, gpointer user_data)

{

    NMEditorWirelessSecurityMethodBinding *binding = user_data;

    if (binding->updating)

        return;

    binding->updating = TRUE;

    g_object_set(binding->target, binding->target_property, get_security_type(binding), NULL);

    binding->updating = FALSE;

}

static void

wireless_connection_changed(NMConnection *connection, gpointer user_data)

{

    NMEditorWirelessSecurityMethodBinding *binding = user_data;

    NMSettingWirelessSecurity *            s_wsec;

    if (binding->updating)

        return;

    s_wsec = nm_connection_get_setting_wireless_security(connection);

    if ((s_wsec && binding->s_wsec_in_use) || (!s_wsec && !binding->s_wsec_in_use))

        return;

    binding->s_wsec_in_use = !binding->s_wsec_in_use;

    wireless_security_changed(NULL, NULL, binding);

}

static void

wireless_security_target_changed(GObject *object, GParamSpec *pspec, gpointer user_data)

{

    NMEditorWirelessSecurityMethodBinding *binding = user_data;

    char *                                 method;

    if (binding->updating)

        return;

    g_object_get(binding->target, binding->target_property, &method, NULL);

    binding->updating = TRUE;

    if (!strcmp(method, "none")) {

        if (!binding->s_wsec_in_use)

            return;

        binding->s_wsec_in_use = FALSE;

        nm_connection_remove_setting(binding->connection, NM_TYPE_SETTING_WIRELESS_SECURITY);

        binding->updating = FALSE;

        return;

    }

    if (!binding->s_wsec_in_use) {

        binding->s_wsec_in_use = TRUE;

        nm_connection_add_setting(binding->connection, NM_SETTING(binding->s_wsec));

    }

    if (!strcmp(method, "wep-key")) {

        g_object_set(binding->s_wsec,

                     NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,

                     "none",

                     NM_SETTING_WIRELESS_SECURITY_AUTH_ALG,

                     "open",

                     NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,

                     NM_WEP_KEY_TYPE_KEY,

                     NULL);

    } else if (!strcmp(method, "wep-passphrase")) {

        g_object_set(binding->s_wsec,

                     NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,

                     "none",

                     NM_SETTING_WIRELESS_SECURITY_AUTH_ALG,

                     "open",

                     NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,

                     NM_WEP_KEY_TYPE_PASSPHRASE,

                     NULL);

    } else if (!strcmp(method, "leap")) {

        g_object_set(binding->s_wsec,

                     NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,

                     "ieee8021x",

                     NM_SETTING_WIRELESS_SECURITY_AUTH_ALG,

                     "leap",

                     NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,

                     NM_WEP_KEY_TYPE_UNKNOWN,

                     NULL);

    } else if (!strcmp(method, "dynamic-wep")) {

        g_object_set(binding->s_wsec,

                     NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,

                     "ieee8021x",

                     NM_SETTING_WIRELESS_SECURITY_AUTH_ALG,

                     "open",

                     NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,

                     NM_WEP_KEY_TYPE_UNKNOWN,

                     NULL);

    } else if (!strcmp(method, "wpa-personal")) {

        g_object_set(binding->s_wsec,

                     NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,

                     "wpa-psk",

                     NM_SETTING_WIRELESS_SECURITY_AUTH_ALG,

                     NULL,

                     NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,

                     NM_WEP_KEY_TYPE_UNKNOWN,

                     NULL);

    } else if (!strcmp(method, "wpa3-personal")) {

        g_object_set(binding->s_wsec,

                     NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,

                     "sae",

                     NM_SETTING_WIRELESS_SECURITY_AUTH_ALG,

                     NULL,

                     NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,

                     NM_WEP_KEY_TYPE_UNKNOWN,

                     NULL);

    } else if (!strcmp(method, "owe")) {

        g_object_set(binding->s_wsec,

                     NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,

                     "owe",

                     NM_SETTING_WIRELESS_SECURITY_AUTH_ALG,

                     NULL,

                     NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,

                     NM_WEP_KEY_TYPE_UNKNOWN,

                     NULL);

    } else if (!strcmp(method, "wpa-enterprise")) {

        g_object_set(binding->s_wsec,

                     NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,

                     "wpa-eap",

                     NM_SETTING_WIRELESS_SECURITY_AUTH_ALG,

                     NULL,

                     NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,

                     NM_WEP_KEY_TYPE_UNKNOWN,

                     NULL);

    } else

        g_warn_if_reached();

    binding->updating = FALSE;

}

static void

wireless_security_target_destroyed(gpointer user_data, GObject *ex_target)

{

    NMEditorWirelessSecurityMethodBinding *binding = user_data;

    g_signal_handlers_disconnect_by_func(binding->s_wsec,

                                         G_CALLBACK(wireless_security_changed),

                                         binding);

    g_object_unref(binding->s_wsec);

    g_object_unref(binding->connection);

    g_free(binding->target_property);

    g_slice_free(NMEditorWirelessSecurityMethodBinding, binding);

}

/**

 * nm_editor_bind_wireless_security_method:

 * @connection: an #NMConnection

 * @s_wsec: an #NMSettingWirelessSecurity

 * @target: the target widget

 * @target_property: the string-valued property on @target to bind

 * @flags: %GBindingFlags

 *

 * Binds the wireless security method on @connection to

 * @target_property on @target (and vice versa if

 * %G_BINDING_BIDIRECTIONAL).

 *

 * @target_property will be of the values "none", "wpa-personal",

 * "wpa-enterprise", "wep-key", "wep-passphrase", "dynamic-wep", or

 * "leap".

 *

 * If binding bidirectionally, @s_wsec will be automatically added to

 * or removed from @connection as needed when @target_property

 * changes.

 */

void

nm_editor_bind_wireless_security_method(NMConnection *             connection,

                                        NMSettingWirelessSecurity *s_wsec,

                                        gpointer                   target,

                                        const char *               target_property,

                                        GBindingFlags              flags)

{

    NMEditorWirelessSecurityMethodBinding *binding;

    char *                                 notify;

    binding = g_slice_new0(NMEditorWirelessSecurityMethodBinding);

    binding->target          = target;

    binding->target_property = g_strdup(target_property);

    if (flags & G_BINDING_BIDIRECTIONAL) {

        notify = g_strdup_printf("notify::%s", target_property);

        g_signal_connect(target, notify, G_CALLBACK(wireless_security_target_changed), binding);

        g_free(notify);

    }

    g_object_weak_ref(target, wireless_security_target_destroyed, binding);

    binding->connection = g_object_ref(connection);

    g_signal_connect(connection,

                     NM_CONNECTION_CHANGED,

                     G_CALLBACK(wireless_connection_changed),

                     binding);

    binding->s_wsec_in_use = (nm_connection_get_setting_wireless_security(connection) != NULL);

    binding->s_wsec = g_object_ref(s_wsec);

    g_signal_connect(s_wsec,

                     "notify::" NM_SETTING_WIRELESS_SECURITY_KEY_MGMT,

                     G_CALLBACK(wireless_security_changed),

                     binding);

    g_signal_connect(s_wsec,

                     "notify::" NM_SETTING_WIRELESS_SECURITY_AUTH_ALG,

                     G_CALLBACK(wireless_security_changed),

                     binding);

    g_signal_connect(s_wsec,

                     "notify::" NM_SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE,

                     G_CALLBACK(wireless_security_changed),

                     binding);

    if (flags & G_BINDING_SYNC_CREATE)

        wireless_security_changed(NULL, NULL, binding);

}

/* WEP key binding */

typedef struct {

    NMSettingWirelessSecurity *s_wsec;

    GObject *                  entry, *key_selector;

    char *                     entry_property, *key_selector_property;

    gboolean updating;

} NMEditorWepKeyBinding;

static void

wep_key_setting_changed(GObject *object, GParamSpec *pspec, gpointer user_data)

{

    NMEditorWepKeyBinding *binding = user_data;

    const char *           key;

    int                    index;

    if (binding->updating)

        return;

    index = nm_setting_wireless_security_get_wep_tx_keyidx(binding->s_wsec);

    key   = nm_setting_wireless_security_get_wep_key(binding->s_wsec, index);

    binding->updating = TRUE;

    g_object_set(binding->key_selector, binding->key_selector_property, index, NULL);

    g_object_set(binding->entry, binding->entry_property, key, NULL);

    binding->updating = FALSE;