/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2018 Red Hat, Inc.
 */

#include "src/core/nm-default-daemon.h"

#include "nm-wifi-p2p-peer.h"

#include <stdlib.h>
#include <linux/if_ether.h>

#include "NetworkManagerUtils.h"
#include "devices/nm-device.h"
#include "libnm-core-intern/nm-core-internal.h"
#include "nm-dbus-manager.h"
#include "libnm-glib-aux/nm-ref-string.h"
#include "nm-setting-wireless.h"
#include "nm-utils.h"
#include "nm-wifi-utils.h"
#include "libnm-platform/nm-platform.h"
#include "supplicant/nm-supplicant-types.h"

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

NM_GOBJECT_PROPERTIES_DEFINE(NMWifiP2PPeer,
                             PROP_NAME,
                             PROP_MANUFACTURER,
                             PROP_MODEL,
                             PROP_MODEL_NUMBER,
                             PROP_SERIAL,
                             PROP_WFD_IES,
                             PROP_HW_ADDRESS,
                             PROP_STRENGTH,
                             PROP_LAST_SEEN,
                             PROP_FLAGS, );

struct _NMWifiP2PPeerPrivate {
    NMRefString *supplicant_path; /* D-Bus object path of this Peer from wpa_supplicant */

    /* Scanned or cached values */
    char *name;
    char *manufacturer;
    char *model;
    char *model_number;
    char *serial;

    char *address;

    GBytes *wfd_ies;

    const char **groups;

    guint8 strength;

    NM80211ApFlags flags; /* General flags */

    /* Non-scanned attributes */
    gint32
        last_seen; /* Timestamp when the Peer was seen lastly (obtained via nm_utils_get_monotonic_timestamp_sec()) */
};

typedef struct _NMWifiP2PPeerPrivate NMWifiP2PPeerPrivate;

struct _NMWifiP2PPeerClass {
    NMDBusObjectClass parent;
};

G_DEFINE_TYPE(NMWifiP2PPeer, nm_wifi_p2p_peer, NM_TYPE_DBUS_OBJECT)

#define NM_WIFI_P2P_PEER_GET_PRIVATE(self) \
    _NM_GET_PRIVATE_PTR(self, NMWifiP2PPeer, NM_IS_WIFI_P2P_PEER)

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

const char **
nm_wifi_p2p_peers_get_paths(const CList *peers_lst_head)
{
    NMWifiP2PPeer *peer;
    const char **  list;
    const char *   path;
    gsize          i, n;

    n    = c_list_length(peers_lst_head);
    list = g_new(const char *, n + 1);

    i = 0;
    if (n > 0) {
        c_list_for_each_entry (peer, peers_lst_head, peers_lst) {
            nm_assert(i < n);
            path = nm_dbus_object_get_path(NM_DBUS_OBJECT(peer));
            nm_assert(path);

            list[i++] = path;
        }
        nm_assert(i <= n);
    }
    list[i] = NULL;
    return list;
}

NMWifiP2PPeer *
nm_wifi_p2p_peers_find_first_compatible(const CList *peers_lst_head, NMConnection *connection)
{
    NMWifiP2PPeer *peer;

    g_return_val_if_fail(connection, NULL);

    c_list_for_each_entry (peer, peers_lst_head, peers_lst) {
        if (nm_wifi_p2p_peer_check_compatible(peer, connection))
            return peer;
    }
    return NULL;
}

NMWifiP2PPeer *
nm_wifi_p2p_peers_find_by_supplicant_path(const CList *peers_lst_head, const char *path)
{
    NMWifiP2PPeer *peer;

    g_return_val_if_fail(path != NULL, NULL);

    c_list_for_each_entry (peer, peers_lst_head, peers_lst) {
        if (nm_streq0(path, nm_wifi_p2p_peer_get_supplicant_path(peer)))
            return peer;
    }
    return NULL;
}

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

NMWifiP2PPeer *
nm_wifi_p2p_peer_lookup_for_device(NMDevice *device, const char *exported_path)
{
    NMWifiP2PPeer *peer;

    g_return_val_if_fail(NM_IS_DEVICE(device), NULL);

    peer = (NMWifiP2PPeer *) nm_dbus_manager_lookup_object(
        nm_dbus_object_get_manager(NM_DBUS_OBJECT(device)),
        exported_path);
    if (!peer || !NM_IS_WIFI_P2P_PEER(peer) || peer->wifi_device != device)
        return NULL;

    return peer;
}

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

const char *
nm_wifi_p2p_peer_get_supplicant_path(NMWifiP2PPeer *peer)
{
    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), NULL);

    return nm_ref_string_get_str(NM_WIFI_P2P_PEER_GET_PRIVATE(peer)->supplicant_path);
}

const char *
nm_wifi_p2p_peer_get_name(const NMWifiP2PPeer *peer)
{
    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), NULL);

    return NM_WIFI_P2P_PEER_GET_PRIVATE(peer)->name;
}

gboolean
nm_wifi_p2p_peer_set_name(NMWifiP2PPeer *peer, const char *str)
{
    NMWifiP2PPeerPrivate *priv = NM_WIFI_P2P_PEER_GET_PRIVATE(peer);

    if (!nm_utils_strdup_reset(&priv->name, str))
        return FALSE;
    _notify(peer, PROP_NAME);
    return TRUE;
}

const char *
nm_wifi_p2p_peer_get_manufacturer(const NMWifiP2PPeer *peer)
{
    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), NULL);

    return NM_WIFI_P2P_PEER_GET_PRIVATE(peer)->manufacturer;
}

gboolean
nm_wifi_p2p_peer_set_manufacturer(NMWifiP2PPeer *peer, const char *str)
{
    NMWifiP2PPeerPrivate *priv = NM_WIFI_P2P_PEER_GET_PRIVATE(peer);

    if (!nm_utils_strdup_reset(&priv->manufacturer, str))
        return FALSE;
    _notify(peer, PROP_MANUFACTURER);
    return TRUE;
}

const char *
nm_wifi_p2p_peer_get_model(const NMWifiP2PPeer *peer)
{
    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), NULL);

    return NM_WIFI_P2P_PEER_GET_PRIVATE(peer)->model;
}

gboolean
nm_wifi_p2p_peer_set_model(NMWifiP2PPeer *peer, const char *str)
{
    NMWifiP2PPeerPrivate *priv = NM_WIFI_P2P_PEER_GET_PRIVATE(peer);

    if (!nm_utils_strdup_reset(&priv->model, str))
        return FALSE;
    _notify(peer, PROP_MODEL);
    return TRUE;
}

const char *
nm_wifi_p2p_peer_get_model_number(const NMWifiP2PPeer *peer)
{
    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), NULL);

    return NM_WIFI_P2P_PEER_GET_PRIVATE(peer)->model_number;
}

gboolean
nm_wifi_p2p_peer_set_model_number(NMWifiP2PPeer *peer, const char *str)
{
    NMWifiP2PPeerPrivate *priv = NM_WIFI_P2P_PEER_GET_PRIVATE(peer);

    if (!nm_utils_strdup_reset(&priv->model_number, str))
        return FALSE;
    _notify(peer, PROP_MODEL_NUMBER);
    return TRUE;
}

const char *
nm_wifi_p2p_peer_get_serial(const NMWifiP2PPeer *peer)
{
    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), NULL);

    return NM_WIFI_P2P_PEER_GET_PRIVATE(peer)->serial;
}

gboolean
nm_wifi_p2p_peer_set_serial(NMWifiP2PPeer *peer, const char *str)
{
    NMWifiP2PPeerPrivate *priv = NM_WIFI_P2P_PEER_GET_PRIVATE(peer);

    if (!nm_utils_strdup_reset(&priv->serial, str))
        return FALSE;
    _notify(peer, PROP_SERIAL);
    return TRUE;
}

GBytes *
nm_wifi_p2p_peer_get_wfd_ies(const NMWifiP2PPeer *peer)
{
    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), NULL);

    return NM_WIFI_P2P_PEER_GET_PRIVATE(peer)->wfd_ies;
}

gboolean
nm_wifi_p2p_peer_set_wfd_ies(NMWifiP2PPeer *peer, GBytes *wfd_ies)
{
    NMWifiP2PPeerPrivate *priv;
    gs_unref_bytes GBytes *wfd_ies_old = NULL;

    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), FALSE);

    priv = NM_WIFI_P2P_PEER_GET_PRIVATE(peer);

    if (nm_gbytes_equal0(priv->wfd_ies, wfd_ies))
        return FALSE;

    wfd_ies_old   = g_steal_pointer(&priv->wfd_ies);
    priv->wfd_ies = wfd_ies ? g_bytes_ref(wfd_ies) : NULL;

    _notify(peer, PROP_WFD_IES);
    return TRUE;
}

const char *const *
nm_wifi_p2p_peer_get_groups(const NMWifiP2PPeer *peer)
{
    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), NULL);

    return NM_WIFI_P2P_PEER_GET_PRIVATE(peer)->groups;
}

const char *
nm_wifi_p2p_peer_get_address(const NMWifiP2PPeer *peer)
{
    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), NULL);

    return NM_WIFI_P2P_PEER_GET_PRIVATE(peer)->address;
}

static gboolean
nm_wifi_p2p_peer_set_address_bin(NMWifiP2PPeer *peer, const guint8 addr[static ETH_ALEN])
{
    NMWifiP2PPeerPrivate *priv = NM_WIFI_P2P_PEER_GET_PRIVATE(peer);

    if (priv->address && nm_utils_hwaddr_matches(addr, ETH_ALEN, priv->address, -1))
        return FALSE;

    g_free(priv->address);
    priv->address = nm_utils_hwaddr_ntoa(addr, ETH_ALEN);
    _notify(peer, PROP_HW_ADDRESS);
    return TRUE;
}

gboolean
nm_wifi_p2p_peer_set_address(NMWifiP2PPeer *peer, const char *addr)
{
    guint8 addr_buf[ETH_ALEN];

    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), FALSE);

    if (!addr || !nm_utils_hwaddr_aton(addr, addr_buf, sizeof(addr_buf)))
        g_return_val_if_reached(FALSE);

    return nm_wifi_p2p_peer_set_address_bin(peer, addr_buf);
}

gint8
nm_wifi_p2p_peer_get_strength(NMWifiP2PPeer *peer)
{
    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), 0);

    return NM_WIFI_P2P_PEER_GET_PRIVATE(peer)->strength;
}

gboolean
nm_wifi_p2p_peer_set_strength(NMWifiP2PPeer *peer, const gint8 strength)
{
    NMWifiP2PPeerPrivate *priv = NM_WIFI_P2P_PEER_GET_PRIVATE(peer);

    if (priv->strength != strength) {
        priv->strength = strength;
        _notify(peer, PROP_STRENGTH);
        return TRUE;
    }
    return FALSE;
}

NM80211ApFlags
nm_wifi_p2p_peer_get_flags(const NMWifiP2PPeer *peer)
{
    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), NM_802_11_AP_FLAGS_NONE);

    return NM_WIFI_P2P_PEER_GET_PRIVATE(peer)->flags;
}

static gboolean
nm_wifi_p2p_peer_set_last_seen(NMWifiP2PPeer *peer, gint32 last_seen)
{
    NMWifiP2PPeerPrivate *priv;

    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), FALSE);

    priv = NM_WIFI_P2P_PEER_GET_PRIVATE(peer);

    if (priv->last_seen != last_seen) {
        priv->last_seen = last_seen;
        _notify(peer, PROP_LAST_SEEN);
        return TRUE;
    }
    return FALSE;
}

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

gboolean
nm_wifi_p2p_peer_update_from_properties(NMWifiP2PPeer *peer, const NMSupplicantPeerInfo *peer_info)
{
    NMWifiP2PPeerPrivate *priv;
    gboolean              changed = FALSE;

    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(peer), FALSE);
    g_return_val_if_fail(peer_info, FALSE);
    nm_assert(NM_IS_REF_STRING(peer_info->peer_path));

    priv = NM_WIFI_P2P_PEER_GET_PRIVATE(peer);

    nm_assert(!priv->supplicant_path || priv->supplicant_path == peer_info->peer_path);

    g_object_freeze_notify(G_OBJECT(peer));

    if (!priv->supplicant_path) {
        priv->supplicant_path = nm_ref_string_ref(peer_info->peer_path);
        changed               = TRUE;
    }

    changed |= nm_wifi_p2p_peer_set_strength(peer, peer_info->signal_percent);
    changed |= nm_wifi_p2p_peer_set_name(peer, peer_info->device_name);
    changed |= nm_wifi_p2p_peer_set_manufacturer(peer, peer_info->manufacturer);
    changed |= nm_wifi_p2p_peer_set_model(peer, peer_info->model);
    changed |= nm_wifi_p2p_peer_set_model_number(peer, peer_info->model_number);
    changed |= nm_wifi_p2p_peer_set_serial(peer, peer_info->serial);

    if (peer_info->address_valid)
        changed |= nm_wifi_p2p_peer_set_address_bin(peer, peer_info->address);
    else {
        /* we don't reset the address. */
    }

    changed |= nm_wifi_p2p_peer_set_wfd_ies(peer, peer_info->ies);
    changed |= nm_wifi_p2p_peer_set_last_seen(peer, peer_info->last_seen_msec / 1000u);

    /* We currently only use the groups information internally to check if
     * the peer is still joined. */
    if (!nm_utils_strv_equal(priv->groups, peer_info->groups)) {
        g_free(priv->groups);
        priv->groups = nm_utils_strv_dup_packed(peer_info->groups, -1);
        changed |= TRUE;
    }

    g_object_thaw_notify(G_OBJECT(peer));

    return changed;
}

const char *
nm_wifi_p2p_peer_to_string(const NMWifiP2PPeer *self, char *str_buf, gsize buf_len, gint32 now_s)
{
    const NMWifiP2PPeerPrivate *priv;
    const char *                supplicant_id = "-";
    const char *                export_path;

    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(self), NULL);

    priv = NM_WIFI_P2P_PEER_GET_PRIVATE(self);

    if (priv->supplicant_path)
        supplicant_id = strrchr(priv->supplicant_path->str, '/') ?: supplicant_id;

    export_path = nm_dbus_object_get_path(NM_DBUS_OBJECT(self));
    if (export_path)
        export_path = strrchr(export_path, '/') ?: export_path;
    else
        export_path = "/";

    g_snprintf(str_buf,
               buf_len,
               "%17s [n:%s, m:%s, mod:%s, mod_num:%s, ser:%s] %3us sup:%s [nm:%s]",
               priv->address ?: "(none)",
               priv->name,
               priv->manufacturer,
               priv->model,
               priv->model_number,
               priv->serial,
               priv->last_seen > 0 ? ((now_s > 0 ? now_s : nm_utils_get_monotonic_timestamp_sec())
                                      - priv->last_seen)
                                   : -1,
               supplicant_id,
               export_path);

    return str_buf;
}

gboolean
nm_wifi_p2p_peer_check_compatible(NMWifiP2PPeer *self, NMConnection *connection)
{
    NMWifiP2PPeerPrivate *priv;
    NMSettingWifiP2P *    s_wifi_p2p;
    const char *          hwaddr;

    g_return_val_if_fail(NM_IS_WIFI_P2P_PEER(self), FALSE);
    g_return_val_if_fail(NM_IS_CONNECTION(connection), FALSE);

    priv = NM_WIFI_P2P_PEER_GET_PRIVATE(self);

    s_wifi_p2p =
        NM_SETTING_WIFI_P2P(nm_connection_get_setting(connection, NM_TYPE_SETTING_WIFI_P2P));
    if (s_wifi_p2p == NULL)
        return FALSE;

    hwaddr = nm_setting_wifi_p2p_get_peer(s_wifi_p2p);
    if (hwaddr && (!priv->address || !nm_utils_hwaddr_matches(hwaddr, -1, priv->address, -1)))
        return FALSE;

    return TRUE;
}

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

static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
    NMWifiP2PPeer *       self = NM_WIFI_P2P_PEER(object);
    NMWifiP2PPeerPrivate *priv = NM_WIFI_P2P_PEER_GET_PRIVATE(self);

    switch (prop_id) {
    case PROP_FLAGS:
        g_value_set_uint(value, priv->flags);
        break;
    case PROP_NAME:
        g_value_set_string(value, priv->name);
        break;
    case PROP_MANUFACTURER:
        g_value_set_string(value, priv->manufacturer);
        break;
    case PROP_MODEL:
        g_value_set_string(value, priv->model);
        break;
    case PROP_MODEL_NUMBER:
        g_value_set_string(value, priv->model_number);
        break;
    case PROP_SERIAL:
        g_value_set_string(value, priv->serial);
        break;
    case PROP_WFD_IES:
        g_value_take_variant(value, nm_utils_gbytes_to_variant_ay(priv->wfd_ies));
        break;
    case PROP_HW_ADDRESS:
        g_value_set_string(value, priv->address);
        break;
    case PROP_STRENGTH:
        g_value_set_uchar(value, priv->strength);
        break;
    case PROP_LAST_SEEN:
        g_value_set_int(value,
                        priv->last_seen > 0
                            ? (int) nm_utils_monotonic_timestamp_as_boottime(priv->last_seen,
                                                                             NM_UTILS_NSEC_PER_SEC)
                            : -1);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
        break;
    }
}

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

static void
nm_wifi_p2p_peer_init(NMWifiP2PPeer *self)
{
    NMWifiP2PPeerPrivate *priv;

    priv = G_TYPE_INSTANCE_GET_PRIVATE(self, NM_TYPE_WIFI_P2P_PEER, NMWifiP2PPeerPrivate);

    self->_priv = priv;

    c_list_init(&self->peers_lst);

    priv->flags     = NM_802_11_AP_FLAGS_NONE;
    priv->last_seen = -1;
}

NMWifiP2PPeer *
nm_wifi_p2p_peer_new_from_properties(const NMSupplicantPeerInfo *peer_info)
{
    NMWifiP2PPeer *peer;

    g_return_val_if_fail(peer_info, NULL);

    peer = g_object_new(NM_TYPE_WIFI_P2P_PEER, NULL);
    nm_wifi_p2p_peer_update_from_properties(peer, peer_info);
    return peer;
}

static void
finalize(GObject *object)
{
    NMWifiP2PPeer *       self = NM_WIFI_P2P_PEER(object);
    NMWifiP2PPeerPrivate *priv = NM_WIFI_P2P_PEER_GET_PRIVATE(self);

    nm_assert(!self->wifi_device);
    nm_assert(c_list_is_empty(&self->peers_lst));

    nm_ref_string_unref(priv->supplicant_path);
    g_free(priv->name);
    g_free(priv->manufacturer);
    g_free(priv->model);
    g_free(priv->model_number);
    g_free(priv->serial);
    g_free(priv->address);
    g_bytes_unref(priv->wfd_ies);
    g_free(priv->groups);

    G_OBJECT_CLASS(nm_wifi_p2p_peer_parent_class)->finalize(object);
}

static const NMDBusInterfaceInfoExtended interface_info_p2p_peer = {
    .parent = NM_DEFINE_GDBUS_INTERFACE_INFO_INIT(
        NM_DBUS_INTERFACE_WIFI_P2P_PEER,
        .properties = NM_DEFINE_GDBUS_PROPERTY_INFOS(
            /* Before 1.24, we wrongly exposed a property "Groups" of type "as". Don't reuse that property name. */
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("Flags", "u", NM_WIFI_P2P_PEER_FLAGS),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("Name", "s", NM_WIFI_P2P_PEER_NAME),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("Manufacturer",
                                                           "s",
                                                           NM_WIFI_P2P_PEER_MANUFACTURER),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("Model", "s", NM_WIFI_P2P_PEER_MODEL),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("ModelNumber",
                                                           "s",
                                                           NM_WIFI_P2P_PEER_MODEL_NUMBER),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("Serial", "s", NM_WIFI_P2P_PEER_SERIAL),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("WfdIEs",
                                                           "ay",
                                                           NM_WIFI_P2P_PEER_WFD_IES),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("HwAddress",
                                                           "s",
                                                           NM_WIFI_P2P_PEER_HW_ADDRESS),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("Strength",
                                                           "y",
                                                           NM_WIFI_P2P_PEER_STRENGTH),
            NM_DEFINE_DBUS_PROPERTY_INFO_EXTENDED_READABLE("LastSeen",
                                                           "i",
                                                           NM_WIFI_P2P_PEER_LAST_SEEN), ), ),
    .legacy_property_changed = FALSE,
};

static void
nm_wifi_p2p_peer_class_init(NMWifiP2PPeerClass *klass)
{
    GObjectClass *     object_class      = G_OBJECT_CLASS(klass);
    NMDBusObjectClass *dbus_object_class = NM_DBUS_OBJECT_CLASS(klass);

    g_type_class_add_private(object_class, sizeof(NMWifiP2PPeerPrivate));

    dbus_object_class->export_path     = NM_DBUS_EXPORT_PATH_NUMBERED(NM_DBUS_PATH_WIFI_P2P_PEER);
    dbus_object_class->interface_infos = NM_DBUS_INTERFACE_INFOS(&interface_info_p2p_peer);

    object_class->get_property = get_property;
    object_class->finalize     = finalize;

    obj_properties[PROP_FLAGS] = g_param_spec_uint(NM_WIFI_P2P_PEER_FLAGS,
                                                   "",
                                                   "",
                                                   NM_802_11_AP_FLAGS_NONE,
                                                   NM_802_11_AP_FLAGS_PRIVACY,
                                                   NM_802_11_AP_FLAGS_NONE,
                                                   G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_NAME] = g_param_spec_string(NM_WIFI_P2P_PEER_NAME,
                                                    "",
                                                    "",
                                                    NULL,
                                                    G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_MANUFACTURER] =
        g_param_spec_string(NM_WIFI_P2P_PEER_MANUFACTURER,
                            "",
                            "",
                            NULL,
                            G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_MODEL] = g_param_spec_string(NM_WIFI_P2P_PEER_MODEL,
                                                     "",
                                                     "",
                                                     NULL,
                                                     G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_MODEL_NUMBER] =
        g_param_spec_string(NM_WIFI_P2P_PEER_MODEL_NUMBER,
                            "",
                            "",
                            NULL,
                            G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_SERIAL] = g_param_spec_string(NM_WIFI_P2P_PEER_SERIAL,
                                                      "",
                                                      "",
                                                      NULL,
                                                      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_WFD_IES] = g_param_spec_variant(NM_WIFI_P2P_PEER_WFD_IES,
                                                        "",
                                                        "",
                                                        G_VARIANT_TYPE("ay"),
                                                        NULL,
                                                        G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_HW_ADDRESS] =
        g_param_spec_string(NM_WIFI_P2P_PEER_HW_ADDRESS,
                            "",
                            "",
                            NULL,
                            G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_STRENGTH] = g_param_spec_uchar(NM_WIFI_P2P_PEER_STRENGTH,
                                                       "",
                                                       "",
                                                       0,
                                                       G_MAXINT8,
                                                       0,
                                                       G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    obj_properties[PROP_LAST_SEEN] = g_param_spec_int(NM_WIFI_P2P_PEER_LAST_SEEN,
                                                      "",
                                                      "",
                                                      -1,
                                                      G_MAXINT,
                                                      -1,
                                                      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
}