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

/*

 * Copyright (C) 2008 - 2017 Red Hat, Inc.

 */

#include "nm-default.h"

#include <stdio.h>

#include <stdarg.h>

#include <unistd.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <sys/socket.h>

#include <linux/pkt_sched.h>

#include "nm-core-internal.h"

#include "settings/plugins/keyfile/nms-keyfile-reader.h"

#include "settings/plugins/keyfile/nms-keyfile-writer.h"

#include "settings/plugins/keyfile/nms-keyfile-utils.h"

#include "nm-test-utils-core.h"

#define TEST_KEYFILES_DIR NM_BUILD_SRCDIR "/src/settings/plugins/keyfile/tests/keyfiles"

#define TEST_SCRATCH_DIR  NM_BUILD_BUILDDIR "/src/settings/plugins/keyfile/tests/keyfiles"

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

static void

check_ip_address(NMSettingIPConfig *config, int idx, const char *address, int plen)

{

    NMIPAddress *ip4 = nm_setting_ip_config_get_address(config, idx);

    g_assert(ip4);

    g_assert_cmpstr(nm_ip_address_get_address(ip4), ==, address);

    g_assert_cmpint(nm_ip_address_get_prefix(ip4), ==, plen);

}

static void

check_ip_route(NMSettingIPConfig *config,

               int                idx,

               const char *       destination,

               int                plen,

               const char *       next_hop,

               gint64             metric)

{

    NMIPRoute *route = nm_setting_ip_config_get_route(config, idx);

    g_assert(route);

    g_assert_cmpstr(nm_ip_route_get_dest(route), ==, destination);

    g_assert_cmpint(nm_ip_route_get_prefix(route), ==, plen);

    g_assert_cmpstr(nm_ip_route_get_next_hop(route), ==, next_hop);

    g_assert_cmpint(nm_ip_route_get_metric(route), ==, metric);

}

#define keyfile_read_connection_from_file(full_filename)                                  \

    ({                                                                                    \

        gs_free_error GError *_error = NULL;                                              \

        NMConnection *        _connection;                                                \

                                                                                          \

        g_assert(full_filename &&full_filename[0] == '/');                                \

                                                                                          \

        _connection =                                                                     \

            nms_keyfile_reader_from_file(full_filename,                                   \

                                         NULL,                                            \

                                         NULL,                                            \

                                         NULL,                                            \

                                         NULL,                                            \

                                         NULL,                                            \

                                         NULL,                                            \

                                         NULL,                                            \

                                         (nmtst_get_rand_uint32() % 2) ? &_error : NULL); \

        nmtst_assert_success(_connection, _error);                                        \

        nmtst_assert_connection_verifies_without_normalization(_connection);              \

                                                                                          \

        _connection;                                                                      \

    })

static void

assert_reread(NMConnection *connection, gboolean normalize_connection, const char *testfile)

{

    gs_unref_object NMConnection *reread           = NULL;

    gs_unref_object NMConnection *connection_clone = NULL;

    NMSettingConnection *         s_con;

    g_assert(NM_IS_CONNECTION(connection));

    reread = keyfile_read_connection_from_file(testfile);

    if (!normalize_connection && (s_con = nm_connection_get_setting_connection(connection))

        && !nm_setting_connection_get_master(s_con)

        && !nm_connection_get_setting_proxy(connection)) {

        connection_clone = nmtst_clone_connection(connection);

        connection       = connection_clone;

        nm_connection_add_setting(connection, nm_setting_proxy_new());

    }

    nmtst_assert_connection_equals(connection, normalize_connection, reread, FALSE);

}

static void

assert_reread_and_unlink(NMConnection *connection,

                         gboolean      normalize_connection,

                         const char *  testfile)

{

    assert_reread(connection, normalize_connection, testfile);

    unlink(testfile);

}

static void

assert_reread_same(NMConnection *connection, NMConnection *reread)

{

    nmtst_assert_connection_verifies_without_normalization(reread);

    nmtst_assert_connection_equals(connection, TRUE, reread, FALSE);

}

static void

write_test_connection_reread(NMConnection * connection,

                             char **        testfile,

                             NMConnection **out_reread,

                             gboolean *     out_reread_same)

{

    uid_t           owner_uid;

    gid_t           owner_grp;

    gboolean        success;

    GError *        error   = NULL;

    GError **       p_error = (nmtst_get_rand_uint32() % 2) ? &error : NULL;

    gs_unref_object NMConnection *connection_normalized = NULL;

    g_assert(NM_IS_CONNECTION(connection));

    g_assert(testfile && !*testfile);

    owner_uid = geteuid();

    owner_grp = getegid();

    connection_normalized = nmtst_connection_duplicate_and_normalize(connection);

    success = nms_keyfile_writer_test_connection(connection_normalized,

                                                 TEST_SCRATCH_DIR,

                                                 owner_uid,

                                                 owner_grp,

                                                 testfile,

                                                 out_reread,

                                                 out_reread_same,

                                                 p_error);

    g_assert_no_error(error);

    g_assert(success);

    g_assert(*testfile && (*testfile)[0]);

}

static void

write_test_connection(NMConnection *connection, char **testfile)

{

    gs_unref_object NMConnection *reread      = NULL;

    gboolean                      reread_same = FALSE;

    write_test_connection_reread(connection, testfile, &reread, &reread_same);

    assert_reread_same(connection, reread);

    g_assert(reread_same);

}

static void

write_test_connection_and_reread(NMConnection *connection, gboolean normalize_connection)

{

    gs_free char *testfile = NULL;

    g_assert(NM_IS_CONNECTION(connection));

    write_test_connection(connection, &testfile);

    assert_reread_and_unlink(connection, normalize_connection, testfile);

}

static GKeyFile *

keyfile_load_from_file(const char *testfile)

{

    GKeyFile *keyfile;

    GError *  error = NULL;

    gboolean  success;

    g_assert(testfile && *testfile);

    keyfile = g_key_file_new();

    success = g_key_file_load_from_file(keyfile, testfile, G_KEY_FILE_NONE, &error);

    g_assert_no_error(error);

    g_assert(success);

    return keyfile;

}

static void

_setting_copy_property_gbytes(NMConnection *src,

                              NMConnection *dst,

                              const char *  setting_name,

                              const char *  property_name)

{

    gs_unref_bytes GBytes *blob = NULL;

    NMSetting *            s_src;

    NMSetting *            s_dst;

    g_assert(NM_IS_CONNECTION(src));

    g_assert(NM_IS_CONNECTION(dst));

    g_assert(setting_name);

    g_assert(property_name);

    s_src = nm_connection_get_setting_by_name(src, setting_name);

    g_assert(NM_IS_SETTING(s_src));

    s_dst = nm_connection_get_setting_by_name(dst, setting_name);

    g_assert(NM_IS_SETTING(s_dst));

    g_object_get(s_src, property_name, &blob, NULL);

    g_object_set(s_dst, property_name, blob, NULL);

}

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

static void

test_read_valid_wired_connection(void)

{

    gs_unref_object NMConnection *connection = NULL;

    NMSettingConnection *         s_con;

    NMSettingWired *              s_wired;

    NMSettingIPConfig *           s_ip4;

    NMSettingIPConfig *           s_ip6;

    NMIPRoute *                   route;

    const char *                  mac;

    char expected_mac_address[ETH_ALEN] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55};

    NMTST_EXPECT_NM_INFO("*ipv4.addresses:*semicolon at the end*addresses1*");

    NMTST_EXPECT_NM_INFO("*ipv4.addresses:*semicolon at the end*addresses2*");

    NMTST_EXPECT_NM_WARN("*missing prefix length*address4*");

    NMTST_EXPECT_NM_WARN("*missing prefix length*address5*");

    NMTST_EXPECT_NM_WARN("*ipv4.dns: ignoring invalid DNS server IPv4 address 'bogus'*");

    NMTST_EXPECT_NM_INFO("*ipv4.routes*semicolon at the end*routes2*");

    NMTST_EXPECT_NM_INFO("*ipv4.routes*semicolon at the end*routes3*");

    NMTST_EXPECT_NM_INFO("*ipv4.routes*semicolon at the end*routes5*");

    NMTST_EXPECT_NM_INFO("*ipv4.routes*semicolon at the end*routes8*");

    NMTST_EXPECT_NM_WARN("*missing prefix length*address4*");

    NMTST_EXPECT_NM_INFO("*ipv6.address*semicolon at the end*address5*");

    NMTST_EXPECT_NM_WARN("*missing prefix length*address5*");

    NMTST_EXPECT_NM_INFO("*ipv6.address*semicolon at the end*address7*");

    NMTST_EXPECT_NM_INFO("*ipv6.routes*semicolon at the end*routes1*");

    NMTST_EXPECT_NM_INFO("*ipv6.route*semicolon at the end*route6*");

    connection = keyfile_read_connection_from_file(TEST_KEYFILES_DIR "/Test_Wired_Connection");

    g_test_assert_expected_messages();

    s_con = nm_connection_get_setting_connection(connection);

    g_assert(s_con);

    g_assert_cmpstr(nm_setting_connection_get_id(s_con), ==, "Test Wired Connection");

    g_assert_cmpstr(nm_setting_connection_get_uuid(s_con),

                    ==,

                    "4e80a56d-c99f-4aad-a6dd-b449bc398c57");

    g_assert_cmpuint(nm_setting_connection_get_timestamp(s_con), ==, 6654332);

    g_assert(nm_setting_connection_get_autoconnect(s_con));

    s_wired = nm_connection_get_setting_wired(connection);

    g_assert(s_wired);

    mac = nm_setting_wired_get_mac_address(s_wired);

    g_assert(mac);

    g_assert(nm_utils_hwaddr_matches(mac, -1, expected_mac_address, sizeof(expected_mac_address)));

    g_assert_cmpint(nm_setting_wired_get_mtu(s_wired), ==, 1400);

    s_ip4 = nm_connection_get_setting_ip4_config(connection);

    g_assert(s_ip4);

    g_assert_cmpstr(nm_setting_ip_config_get_method(s_ip4),

                    ==,

                    NM_SETTING_IP4_CONFIG_METHOD_MANUAL);

    g_assert_cmpint(nm_setting_ip_config_get_num_dns(s_ip4), ==, 2);

    g_assert_cmpstr(nm_setting_ip_config_get_dns(s_ip4, 0), ==, "4.2.2.1");

    g_assert_cmpstr(nm_setting_ip_config_get_dns(s_ip4, 1), ==, "4.2.2.2");

    /* IPv4 addresses */

    g_assert_cmpint(nm_setting_ip_config_get_num_addresses(s_ip4), ==, 10);

    check_ip_address(s_ip4, 0, "2.3.4.5", 24);

    check_ip_address(s_ip4, 1, "192.168.0.5", 24);

    check_ip_address(s_ip4, 2, "1.2.3.4", 16);

    check_ip_address(s_ip4, 3, "3.4.5.6", 16);

    check_ip_address(s_ip4, 4, "4.5.6.7", 24);

    check_ip_address(s_ip4, 5, "5.6.7.8", 24);

    check_ip_address(s_ip4, 6, "1.2.3.30", 24);

    check_ip_address(s_ip4, 7, "1.2.3.30", 25);

    check_ip_address(s_ip4, 8, "1.2.3.31", 24);

    check_ip_address(s_ip4, 9, "1.2.3.31", 25);

    /* IPv4 gateway */

    g_assert_cmpstr(nm_setting_ip_config_get_gateway(s_ip4), ==, "2.3.4.6");

    /* IPv4 routes */

    g_assert_cmpint(nm_setting_ip_config_get_num_routes(s_ip4), ==, 14);

    check_ip_route(s_ip4, 0, "5.6.7.8", 32, NULL, -1);

    check_ip_route(s_ip4, 1, "1.2.3.0", 24, "2.3.4.8", 99);

    check_ip_route(s_ip4, 2, "1.1.1.2", 12, NULL, -1);

    check_ip_route(s_ip4, 3, "1.1.1.3", 13, NULL, -1);

    check_ip_route(s_ip4, 4, "1.1.1.4", 14, "2.2.2.4", -1);

    check_ip_route(s_ip4, 5, "1.1.1.5", 15, "2.2.2.5", -1);

    check_ip_route(s_ip4, 6, "1.1.1.6", 16, "2.2.2.6", 0);

    check_ip_route(s_ip4, 7, "1.1.1.7", 17, NULL, -1);

    check_ip_route(s_ip4, 8, "1.1.1.8", 18, NULL, -1);

    check_ip_route(s_ip4, 9, "1.1.1.9", 19, NULL, 0);

    check_ip_route(s_ip4, 10, "1.1.1.10", 21, NULL, 0);

    check_ip_route(s_ip4, 11, "1.1.1.10", 20, NULL, 0);

    check_ip_route(s_ip4, 12, "1.1.1.11", 21, NULL, 21);

    check_ip_route(s_ip4, 13, "1.2.3.4", 32, NULL, -1);

    /* Route attributes */

    route = nm_setting_ip_config_get_route(s_ip4, 12);

    g_assert(route);

    nmtst_assert_route_attribute_uint32(route, NM_IP_ROUTE_ATTRIBUTE_CWND, 10);

    nmtst_assert_route_attribute_uint32(route, NM_IP_ROUTE_ATTRIBUTE_MTU, 1430);

    nmtst_assert_route_attribute_boolean(route, NM_IP_ROUTE_ATTRIBUTE_LOCK_CWND, TRUE);

    nmtst_assert_route_attribute_string(route, NM_IP_ROUTE_ATTRIBUTE_SRC, "7.7.7.7");

    nmtst_assert_route_attribute_string(route, NM_IP_ROUTE_ATTRIBUTE_TYPE, "unicast");

    route = nm_setting_ip_config_get_route(s_ip4, 13);

    g_assert(route);

    nmtst_assert_route_attribute_string(route, NM_IP_ROUTE_ATTRIBUTE_TYPE, "local");

    s_ip6 = nm_connection_get_setting_ip6_config(connection);

    g_assert(s_ip6);

    g_assert_cmpstr(nm_setting_ip_config_get_method(s_ip6),

                    ==,

                    NM_SETTING_IP6_CONFIG_METHOD_MANUAL);

    g_assert_cmpint(nm_setting_ip_config_get_num_dns(s_ip6), ==, 2);

    g_assert_cmpstr(nm_setting_ip_config_get_dns(s_ip6, 0), ==, "1111:dddd::aaaa");

    g_assert_cmpstr(nm_setting_ip_config_get_dns(s_ip6, 1), ==, "1::cafe");

    g_assert_cmpint(nm_setting_ip_config_get_num_dns_searches(s_ip6), ==, 3);

    g_assert_cmpstr(nm_setting_ip_config_get_dns_search(s_ip6, 0), ==, "super-domain.com");

    g_assert_cmpstr(nm_setting_ip_config_get_dns_search(s_ip6, 1), ==, "redhat.com");

    g_assert_cmpstr(nm_setting_ip_config_get_dns_search(s_ip6, 2), ==, "gnu.org");

    /* IPv6 addresses */

    g_assert_cmpint(nm_setting_ip_config_get_num_addresses(s_ip6), ==, 10);

    check_ip_address(s_ip6, 0, "2:3:4:5:6:7:8:9", 64);

    check_ip_address(s_ip6, 1, "abcd:1234:ffff::cdde", 64);

    check_ip_address(s_ip6, 2, "1:2:3:4:5:6:7:8", 96);

    check_ip_address(s_ip6, 3, "3:4:5:6:7:8:9:0", 128);

    check_ip_address(s_ip6, 4, "3:4:5:6:7:8:9:14", 64);

    check_ip_address(s_ip6, 5, "3:4:5:6:7:8:9:15", 64);

    check_ip_address(s_ip6, 6, "3:4:5:6:7:8:9:16", 66);

    check_ip_address(s_ip6, 7, "3:4:5:6:7:8:9:17", 67);

    check_ip_address(s_ip6, 8, "3:4:5:6:7:8:9:18", 68);

    check_ip_address(s_ip6, 9, "3:4:5:6:7:8:9:19", 69);

    /* IPv6 gateway */

    g_assert_cmpstr(nm_setting_ip_config_get_gateway(s_ip6), ==, "2:3:4:5:1:2:3:4");

    /* Routes */

    g_assert_cmpint(nm_setting_ip_config_get_num_routes(s_ip6), ==, 7);

    check_ip_route(s_ip6, 0, "d:e:f:0:1:2:3:4", 64, "f:e:d:c:1:2:3:4", -1);

    check_ip_route(s_ip6, 1, "a:b:c:d::", 64, "f:e:d:c:1:2:3:4", 99);

    check_ip_route(s_ip6, 2, "8:7:6:5:4:3:2:1", 128, NULL, -1);

    check_ip_route(s_ip6, 3, "6:7:8:9:0:1:2:3", 126, NULL, 1);

    check_ip_route(s_ip6, 4, "7:8:9:0:1:2:3:4", 125, NULL, 5);

    check_ip_route(s_ip6, 5, "8:9:0:1:2:3:4:5", 124, NULL, 6);

    check_ip_route(s_ip6, 6, "8:9:0:1:2:3:4:6", 123, NULL, -1);

    /* Route attributes */

    route = nm_setting_ip_config_get_route(s_ip6, 6);

    g_assert(route);

    nmtst_assert_route_attribute_string(route, NM_IP_ROUTE_ATTRIBUTE_FROM, "abce::/63");

}

static void

add_one_ip_address(NMSettingIPConfig *s_ip, const char *addr, guint32 prefix)

{

    NMIPAddress * ip_addr;

    gs_free_error GError *error = NULL;

    ip_addr = nm_ip_address_new(NM_IS_SETTING_IP4_CONFIG(s_ip) ? AF_INET : AF_INET6,

                                addr,

                                prefix,

                                &error);

    g_assert_no_error(error);

    nm_setting_ip_config_add_address(s_ip, ip_addr);

    nm_ip_address_unref(ip_addr);

}

static void

add_one_ip_route(NMSettingIPConfig *s_ip,

                 const char *       dest,

                 const char *       nh,

                 guint32            prefix,

                 gint64             metric)

{

    NMIPRoute *   route;

    gs_free_error GError *error = NULL;

    g_assert(prefix > 0);

    route = nm_ip_route_new(NM_IS_SETTING_IP4_CONFIG(s_ip) ? AF_INET : AF_INET6,

                            dest,

                            prefix,

                            nh,

                            metric,

                            &error);

    g_assert_no_error(error);

    nm_setting_ip_config_add_route(s_ip, route);

    nm_ip_route_unref(route);

}

static void

test_write_wired_connection(void)

{

    NMTST_UUID_INIT(uuid);

    gs_unref_object NMConnection *connection = NULL;

    NMSettingConnection *         s_con;

    NMSettingWired *              s_wired;

    NMSettingIPConfig *           s_ip4;

    NMSettingIPConfig *           s_ip6;

    NMIPRoute *                   rt;

    const char *                  mac         = "99:88:77:66:55:44";

    const char *                  dns1        = "4.2.2.1";

    const char *                  dns2        = "4.2.2.2";

    const char *                  address1    = "192.168.0.5";

    const char *                  address2    = "1.2.3.4";

    const char *                  gw          = "192.168.0.1";

    const char *                  route1      = "10.10.10.2";

    const char *                  route1_nh   = "10.10.10.1";

    const char *                  route2      = "1.1.1.1";

    const char *                  route2_nh   = "1.2.1.1";

    const char *                  route3      = "2.2.2.2";

    const char *                  route3_nh   = NULL;

    const char *                  route4      = "3.3.3.3";

    const char *                  route4_nh   = NULL;

    const char *                  dns6_1      = "1::cafe";

    const char *                  dns6_2      = "2::cafe";

    const char *                  address6_1  = "abcd::beef";

    const char *                  address6_2  = "dcba::beef";

    const char *                  route6_1    = "1:2:3:4:5:6:7:8";

    const char *                  route6_1_nh = "8:7:6:5:4:3:2:1";

    const char *                  route6_2    = "2001::1000";

    const char *                  route6_2_nh = "2001::1111";

    const char *                  route6_3    = "4:5:6:7:8:9:0:1";

    const char *                  route6_3_nh = "::";

    const char *                  route6_4    = "5:6:7:8:9:0:1:2";

    const char *                  route6_4_nh = "::";

    guint64                       timestamp   = 0x12345678L;

    GError *                      error       = NULL;

    connection = nm_simple_connection_new();

    /* Connection setting */

    s_con = NM_SETTING_CONNECTION(nm_setting_connection_new());

    nm_connection_add_setting(connection, NM_SETTING(s_con));

    g_object_set(s_con,

                 NM_SETTING_CONNECTION_ID,

                 "Work Wired",

                 NM_SETTING_CONNECTION_UUID,

                 uuid,

                 NM_SETTING_CONNECTION_AUTOCONNECT,

                 FALSE,

                 NM_SETTING_CONNECTION_TYPE,

                 NM_SETTING_WIRED_SETTING_NAME,

                 NM_SETTING_CONNECTION_TIMESTAMP,

                 timestamp,

                 NULL);

    /* Wired setting */

    s_wired = NM_SETTING_WIRED(nm_setting_wired_new());

    nm_connection_add_setting(connection, NM_SETTING(s_wired));

    g_object_set(s_wired, NM_SETTING_WIRED_MAC_ADDRESS, mac, NM_SETTING_WIRED_MTU, 900, NULL);

    /* IP4 setting */

    s_ip4 = NM_SETTING_IP_CONFIG(nm_setting_ip4_config_new());

    nm_connection_add_setting(connection, NM_SETTING(s_ip4));

    g_object_set(s_ip4,

                 NM_SETTING_IP_CONFIG_METHOD,

                 NM_SETTING_IP4_CONFIG_METHOD_MANUAL,

                 NM_SETTING_IP_CONFIG_GATEWAY,

                 gw,

                 NULL);

    /* Addresses */

    add_one_ip_address(s_ip4, address1, 24);

    add_one_ip_address(s_ip4, address2, 8);

    /* Routes */

    add_one_ip_route(s_ip4, route1, route1_nh, 24, 3);

    add_one_ip_route(s_ip4, route2, route2_nh, 8, 1);

    add_one_ip_route(s_ip4, route3, route3_nh, 7, -1);

    rt = nm_ip_route_new(AF_INET, route4, 6, route4_nh, 4, &error);

    g_assert_no_error(error);

    nm_ip_route_set_attribute(rt, NM_IP_ROUTE_ATTRIBUTE_CWND, g_variant_new_uint32(10));

    nm_ip_route_set_attribute(rt, NM_IP_ROUTE_ATTRIBUTE_MTU, g_variant_new_uint32(1492));

    nm_ip_route_set_attribute(rt, NM_IP_ROUTE_ATTRIBUTE_SRC, g_variant_new_string("1.2.3.4"));

    g_assert(nm_setting_ip_config_add_route(s_ip4, rt));

    nm_ip_route_unref(rt);

    /* DNS servers */

    nm_setting_ip_config_add_dns(s_ip4, dns1);

    nm_setting_ip_config_add_dns(s_ip4, dns2);

    /* IP6 setting */

    s_ip6 = NM_SETTING_IP_CONFIG(nm_setting_ip6_config_new());

    nm_connection_add_setting(connection, NM_SETTING(s_ip6));

    g_object_set(s_ip6, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP6_CONFIG_METHOD_MANUAL, NULL);

    /* Addresses */

    add_one_ip_address(s_ip6, address6_1, 64);

    add_one_ip_address(s_ip6, address6_2, 56);

    /* Routes */

    add_one_ip_route(s_ip6, route6_1, route6_1_nh, 64, 3);

    add_one_ip_route(s_ip6, route6_2, route6_2_nh, 56, 1);

    add_one_ip_route(s_ip6, route6_3, route6_3_nh, 63, 5);

    add_one_ip_route(s_ip6, route6_4, route6_4_nh, 62, -1);

    /* DNS servers */

    nm_setting_ip_config_add_dns(s_ip6, dns6_1);

    nm_setting_ip_config_add_dns(s_ip6, dns6_2);

    /* DNS searches */

    nm_setting_ip_config_add_dns_search(s_ip6, "wallaceandgromit.com");

    write_test_connection_and_reread(connection, FALSE);

}

static void

test_read_ip6_wired_connection(void)

{

    gs_unref_object NMConnection *connection = NULL;

    NMSettingConnection *         s_con;

    NMSettingWired *              s_wired;

    NMSettingIPConfig *           s_ip4;

    NMSettingIPConfig *           s_ip6;

    connection = keyfile_read_connection_from_file(TEST_KEYFILES_DIR "/Test_Wired_Connection_IP6");

    s_con = nm_connection_get_setting_connection(connection);

    g_assert(s_con);

    g_assert_cmpstr(nm_setting_connection_get_id(s_con), ==, "Test Wired Connection IP6");

    g_assert_cmpstr(nm_setting_connection_get_uuid(s_con),

                    ==,

                    "4e80a56d-c99f-4aad-a6dd-b449bc398c57");

    s_wired = nm_connection_get_setting_wired(connection);

    g_assert(s_wired);

    s_ip4 = nm_connection_get_setting_ip4_config(connection);

    g_assert(s_ip4);

    g_assert_cmpstr(nm_setting_ip_config_get_method(s_ip4),

                    ==,

                    NM_SETTING_IP4_CONFIG_METHOD_DISABLED);

    g_assert_cmpint(nm_setting_ip_config_get_num_addresses(s_ip4), ==, 0);

    s_ip6 = nm_connection_get_setting_ip6_config(connection);

    g_assert(s_ip6);

    g_assert_cmpstr(nm_setting_ip_config_get_method(s_ip6),

                    ==,

                    NM_SETTING_IP6_CONFIG_METHOD_MANUAL);

    g_assert_cmpint(nm_setting_ip_config_get_num_addresses(s_ip6), ==, 1);

    check_ip_address(s_ip6, 0, "abcd:1234:ffff::cdde", 64);

    g_assert_cmpstr(nm_setting_ip_config_get_gateway(s_ip6), ==, "abcd:1234:ffff::cdd1");

}

static void

test_write_ip6_wired_connection(void)

{

    NMTST_UUID_INIT(uuid);

    gs_unref_object NMConnection *connection = NULL;

    NMSettingConnection *         s_con;

    NMSettingWired *              s_wired;

    NMSettingIPConfig *           s_ip4;

    NMSettingIPConfig *           s_ip6;

    const char *                  dns     = "1::cafe";

    const char *                  address = "abcd::beef";

    const char *                  gw      = "dcba::beef";

    connection = nm_simple_connection_new();

    /* Connection setting */

    s_con = NM_SETTING_CONNECTION(nm_setting_connection_new());

    nm_connection_add_setting(connection, NM_SETTING(s_con));

    g_object_set(s_con,

                 NM_SETTING_CONNECTION_ID,

                 "Work Wired IP6",

                 NM_SETTING_CONNECTION_UUID,

                 uuid,

                 NM_SETTING_CONNECTION_AUTOCONNECT,

                 FALSE,

                 NM_SETTING_CONNECTION_TYPE,

                 NM_SETTING_WIRED_SETTING_NAME,

                 NULL);

    /* Wired setting */

    s_wired = NM_SETTING_WIRED(nm_setting_wired_new());

    nm_connection_add_setting(connection, NM_SETTING(s_wired));

    /* IP4 setting */

    s_ip4 = NM_SETTING_IP_CONFIG(nm_setting_ip4_config_new());

    nm_connection_add_setting(connection, NM_SETTING(s_ip4));

    g_object_set(s_ip4, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_DISABLED, NULL);

    /* IP6 setting */

    s_ip6 = NM_SETTING_IP_CONFIG(nm_setting_ip6_config_new());

    nm_connection_add_setting(connection, NM_SETTING(s_ip6));

    g_object_set(s_ip6,

                 NM_SETTING_IP_CONFIG_METHOD,

                 NM_SETTING_IP6_CONFIG_METHOD_MANUAL,

                 NM_SETTING_IP_CONFIG_GATEWAY,

                 gw,

                 NULL);

    /* Addresses */

    add_one_ip_address(s_ip6, address, 64);

    /* DNS servers */

    nm_setting_ip_config_add_dns(s_ip6, dns);

    /* DNS searches */

    nm_setting_ip_config_add_dns_search(s_ip6, "wallaceandgromit.com");

    write_test_connection_and_reread(connection, FALSE);

}

static void

test_read_wired_mac_case(void)

{

    gs_unref_object NMConnection *connection = NULL;

    NMSettingConnection *         s_con;

    NMSettingWired *              s_wired;

    const char *                  mac;

    char expected_mac_address[ETH_ALEN] = {0x00, 0x11, 0xaa, 0xbb, 0xcc, 0x55};

    NMTST_EXPECT_NM_INFO("*ipv4.addresses*semicolon at the end*addresses1*");

    NMTST_EXPECT_NM_INFO("*ipv4.addresses*semicolon at the end*addresses2*");

    NMTST_EXPECT_NM_INFO("*ipv6.routes*semicolon at the end*routes1*");

    connection =

        keyfile_read_connection_from_file(TEST_KEYFILES_DIR "/Test_Wired_Connection_MAC_Case");

    g_test_assert_expected_messages();

    s_con = nm_connection_get_setting_connection(connection);

    g_assert(s_con);

    g_assert_cmpstr(nm_setting_connection_get_id(s_con), ==, "Test Wired Connection MAC Case");

    g_assert_cmpstr(nm_setting_connection_get_uuid(s_con),

                    ==,

                    "4e80a56d-c99f-4aad-a6dd-b449bc398c57");

    s_wired = nm_connection_get_setting_wired(connection);

    g_assert(s_wired);

    mac = nm_setting_wired_get_mac_address(s_wired);

    g_assert(mac);

    g_assert(nm_utils_hwaddr_matches(mac, -1, expected_mac_address, sizeof(expected_mac_address)));

}

static void

test_read_mac_old_format(void)

{

    gs_unref_object NMConnection *connection = NULL;

    NMSettingWired *              s_wired;

    const char *                  mac;

    char                          expected_mac[ETH_ALEN] = {0x00, 0x11, 0xaa, 0xbb, 0xcc, 0x55};

    char expected_cloned_mac[ETH_ALEN]                   = {0x00, 0x16, 0xaa, 0xbb, 0xcc, 0xfe};

    connection = keyfile_read_connection_from_file(TEST_KEYFILES_DIR "/Test_MAC_Old_Format");

    s_wired = nm_connection_get_setting_wired(connection);

    g_assert(s_wired);

    mac = nm_setting_wired_get_mac_address(s_wired);

    g_assert(mac);

    g_assert(nm_utils_hwaddr_matches(mac, -1, expected_mac, ETH_ALEN));

    mac = nm_setting_wired_get_cloned_mac_address(s_wired);

    g_assert(mac);

    g_assert(nm_utils_hwaddr_matches(mac, -1, expected_cloned_mac, ETH_ALEN));

}

static void

test_read_mac_ib_old_format(void)

{

    gs_unref_object NMConnection *connection = NULL;

    NMSettingInfiniband *         s_ib;

    const char *                  mac;

    guint8 expected_mac[INFINIBAND_ALEN] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66,

                                            0x77, 0x88, 0x99, 0x01, 0x12, 0x23, 0x34,

                                            0x45, 0x56, 0x67, 0x78, 0x89, 0x90};

    connection = keyfile_read_connection_from_file(TEST_KEYFILES_DIR "/Test_MAC_IB_Old_Format");

    s_ib = nm_connection_get_setting_infiniband(connection);

    g_assert(s_ib);

    /* MAC address */

    mac = nm_setting_infiniband_get_mac_address(s_ib);

    g_assert(mac);

    g_assert(nm_utils_hwaddr_matches(mac, -1, expected_mac, sizeof(expected_mac)));

}

static void

test_read_valid_wireless_connection(void)

{

    gs_unref_object NMConnection *connection = NULL;

    NMSettingConnection *         s_con;

    NMSettingWireless *           s_wireless;

    NMSettingIPConfig *           s_ip4;

    const char *                  bssid;

    const guint8                  expected_bssid[ETH_ALEN] = {0x00, 0x1a, 0x33, 0x44, 0x99, 0x82};

    connection = keyfile_read_connection_from_file(TEST_KEYFILES_DIR "/Test_Wireless_Connection");

    s_con = nm_connection_get_setting_connection(connection);

    g_assert(s_con);

    g_assert_cmpstr(nm_setting_connection_get_id(s_con), ==, "Test Wireless Connection");

    g_assert_cmpstr(nm_setting_connection_get_uuid(s_con),

                    ==,

                    "2f962388-e5f3-45af-a62c-ac220b8f7baa");

    g_assert_cmpuint(nm_setting_connection_get_timestamp(s_con), ==, 1226604314);

    g_assert(nm_setting_connection_get_autoconnect(s_con) == FALSE);

    s_wireless = nm_connection_get_setting_wireless(connection);

    g_assert(s_wireless);

    bssid = nm_setting_wireless_get_bssid(s_wireless);

    g_assert(bssid);

    g_assert(nm_utils_hwaddr_matches(bssid, -1, expected_bssid, sizeof(expected_bssid)));

    s_ip4 = nm_connection_get_setting_ip4_config(connection);

    g_assert(s_ip4);

    g_assert_cmpstr(nm_setting_ip_config_get_method(s_ip4), ==, NM_SETTING_IP4_CONFIG_METHOD_AUTO);

}

static void

test_write_wireless_connection(void)

{

    NMTST_UUID_INIT(uuid);

    gs_unref_object NMConnection *connection = NULL;

    NMSettingConnection *         s_con;

    NMSettingWireless *           s_wireless;

    NMSettingIPConfig *           s_ip4;

    NMSettingIPConfig *           s_ip6;

    const char *                  bssid = "aa:b9:a1:74:55:44";

    GBytes *                      ssid;

    unsigned char                 tmpssid[] = {0x31, 0x33, 0x33, 0x37};

    guint64                       timestamp = 0x12344433L;

    connection = nm_simple_connection_new();

    /* Connection setting */

    s_con = NM_SETTING_CONNECTION(nm_setting_connection_new());

    nm_connection_add_setting(connection, NM_SETTING(s_con));

    g_object_set(s_con,

                 NM_SETTING_CONNECTION_ID,

                 "Work Wireless",

                 NM_SETTING_CONNECTION_UUID,

                 uuid,

                 NM_SETTING_CONNECTION_AUTOCONNECT,

                 FALSE,

                 NM_SETTING_CONNECTION_TYPE,

                 NM_SETTING_WIRELESS_SETTING_NAME,

                 NM_SETTING_CONNECTION_TIMESTAMP,

                 timestamp,

                 NULL);

    /* Wireless setting */

    s_wireless = NM_SETTING_WIRELESS(nm_setting_wireless_new());

    nm_connection_add_setting(connection, NM_SETTING(s_wireless));

    ssid = g_bytes_new(tmpssid, sizeof(tmpssid));

    g_object_set(s_wireless,

                 NM_SETTING_WIRELESS_BSSID,

                 bssid,

                 NM_SETTING_WIRELESS_SSID,

                 ssid,

                 NM_SETTING_WIRED_MTU,

                 1000,

                 NULL);

    g_bytes_unref(ssid);

    /* IP4 setting */

    s_ip4 = NM_SETTING_IP_CONFIG(nm_setting_ip4_config_new());

    nm_connection_add_setting(connection, NM_SETTING(s_ip4));

    g_object_set(s_ip4, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NULL);

    /* IP6 setting */

    s_ip6 = NM_SETTING_IP_CONFIG(nm_setting_ip6_config_new());

    nm_connection_add_setting(connection, NM_SETTING(s_ip6));

    g_object_set(s_ip6, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP6_CONFIG_METHOD_AUTO, NULL);

    write_test_connection_and_reread(connection, FALSE);

}

static void

test_read_string_ssid(void)

{

    gs_unref_object NMConnection *connection = NULL;

    NMSettingWireless *           s_wireless;

    GBytes *                      ssid;

    const guint8 *                ssid_data;

    gsize                         ssid_len;

    const char *                  expected_ssid = "blah blah ssid 1234";

    connection = keyfile_read_connection_from_file(TEST_KEYFILES_DIR "/Test_String_SSID");

    s_wireless = nm_connection_get_setting_wireless(connection);

    g_assert(s_wireless);

    ssid = nm_setting_wireless_get_ssid(s_wireless);

    g_assert(ssid);

    ssid_data = g_bytes_get_data(ssid, &ssid_len);

    g_assert_cmpmem(ssid_data, ssid_len, expected_ssid, strlen(expected_ssid));

}

static void

test_write_string_ssid(void)

{

    NMTST_UUID_INIT(uuid);

    gs_unref_object NMConnection *connection = NULL;

    NMSettingConnection *         s_con;

    NMSettingWireless *           s_wireless;

    NMSettingIPConfig *           s_ip4;

    char *                        tmp;

    gs_free char *                testfile = NULL;

    GBytes *                      ssid;

    unsigned char                 tmpssid[] = {65, 49, 50, 51, 32, 46, 92, 46, 36, 37, 126, 93};

    nm_auto_unref_keyfile GKeyFile *keyfile = NULL;

    connection = nm_simple_connection_new();

    /* Connection setting */

    s_con = NM_SETTING_CONNECTION(nm_setting_connection_new());

    nm_connection_add_setting(connection, NM_SETTING(s_con));

    g_object_set(s_con,

                 NM_SETTING_CONNECTION_ID,

                 "String SSID Test",

                 NM_SETTING_CONNECTION_UUID,

                 uuid,

                 NM_SETTING_CONNECTION_TYPE,

                 NM_SETTING_WIRELESS_SETTING_NAME,

                 NULL);

    /* Wireless setting */

    s_wireless = NM_SETTING_WIRELESS(nm_setting_wireless_new());

    nm_connection_add_setting(connection, NM_SETTING(s_wireless));

    ssid = g_bytes_new(tmpssid, sizeof(tmpssid));

    g_object_set(s_wireless, NM_SETTING_WIRELESS_SSID, ssid, NULL);

    g_bytes_unref(ssid);

    /* IP4 setting */

    s_ip4 = NM_SETTING_IP_CONFIG(nm_setting_ip4_config_new());

    nm_connection_add_setting(connection, NM_SETTING(s_ip4));

    g_object_set(s_ip4, NM_SETTING_IP_CONFIG_METHOD, NM_SETTING_IP4_CONFIG_METHOD_AUTO, NULL);

    write_test_connection(connection, &testfile);