HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/network/networkd-json.c

72,068 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 137653bd66754c6aed3337dcce9e420cc355e1be

Lines 1001–1726 of 1,726

}
 
static int nta_append_json(const char *nta, NetworkConfigSource s, sd_json_variant **array) {
        assert(nta);
        assert(array);
 
        return sd_json_variant_append_arraybo(
                        array,
                        SD_JSON_BUILD_PAIR_STRING("DNSSECNegativeTrustAnchor", nta),
                        SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(s)));
}
 
static int ntas_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
        const char *nta;
        int r;
 
        assert(link);
        assert(v);
 
        if (!link->network)
                return 0;
 
        SET_FOREACH(nta, link->dnssec_negative_trust_anchors ?: link->network->dnssec_negative_trust_anchors) {
                r = nta_append_json(nta,
                                   link->dnssec_negative_trust_anchors ? NETWORK_CONFIG_SOURCE_RUNTIME : NETWORK_CONFIG_SOURCE_STATIC,
                                   &array);
                if (r < 0)
                        return r;
        }
 
        return json_variant_set_field_non_null(v, "DNSSECNegativeTrustAnchors", array);
}
 
static int dns_misc_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
        ResolveSupport resolve_support;
        NetworkConfigSource source;
        DnsOverTlsMode mode;
        int t, r;
 
        assert(link);
        assert(v);
 
        if (!link->network)
                return 0;
 
        resolve_support = link->llmnr >= 0 ? link->llmnr : link->network->llmnr;
        if (resolve_support >= 0) {
                source = link->llmnr >= 0 ? NETWORK_CONFIG_SOURCE_RUNTIME : NETWORK_CONFIG_SOURCE_STATIC;
 
                r = sd_json_variant_append_arraybo(
                                &array,
                                SD_JSON_BUILD_PAIR_STRING("LLMNR", resolve_support_to_string(resolve_support)),
                                SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source)));
                if (r < 0)
                        return r;
        }
 
        resolve_support = link->mdns >= 0 ? link->mdns : link->network->mdns;
        if (resolve_support >= 0) {
                source = link->mdns >= 0 ? NETWORK_CONFIG_SOURCE_RUNTIME : NETWORK_CONFIG_SOURCE_STATIC;
 
                r = sd_json_variant_append_arraybo(
                                &array,
                                SD_JSON_BUILD_PAIR_STRING("MDNS", resolve_support_to_string(resolve_support)),
                                SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source)));
                if (r < 0)
                        return r;
        }
 
        t = link->dns_default_route >= 0 ? link->dns_default_route : link->network->dns_default_route;
        if (t >= 0) {
                source = link->dns_default_route >= 0 ? NETWORK_CONFIG_SOURCE_RUNTIME : NETWORK_CONFIG_SOURCE_STATIC;
 
                r = sd_json_variant_append_arraybo(
                                &array,
                                SD_JSON_BUILD_PAIR_BOOLEAN("DNSDefaultRoute", t),
                                SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source)));
                if (r < 0)
                        return r;
        }
 
        mode = link->dns_over_tls_mode >= 0 ? link->dns_over_tls_mode : link->network->dns_over_tls_mode;
        if (mode >= 0) {
                source = link->dns_over_tls_mode >= 0 ? NETWORK_CONFIG_SOURCE_RUNTIME : NETWORK_CONFIG_SOURCE_STATIC;
 
                r = sd_json_variant_append_arraybo(
                                &array,
                                SD_JSON_BUILD_PAIR_STRING("DNSOverTLS", dns_over_tls_mode_to_string(mode)),
                                SD_JSON_BUILD_PAIR_STRING("ConfigSource", network_config_source_to_string(source)));
                if (r < 0)
                        return r;
        }
 
        return json_variant_set_field_non_null(v, "DNSSettings", array);
}
 
static int captive_portal_append_json(Link *link, sd_json_variant **v) {
        const char *captive_portal;
        int r;
 
        assert(link);
        assert(v);
 
        r = link_get_captive_portal(link, &captive_portal);
        if (r <= 0)
                return r;
 
        return sd_json_variant_merge_objectbo(v, SD_JSON_BUILD_PAIR_STRING("CaptivePortal", captive_portal));
}
 
static int pref64_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL, *w = NULL;
        NDiscPREF64 *i;
        int r;
 
        assert(link);
        assert(v);
 
        if (!link->network || !link->network->ndisc_use_pref64)
                return 0;
 
        SET_FOREACH(i, link->ndisc_pref64) {
                r = sd_json_variant_append_arraybo(
                                &array,
                                JSON_BUILD_PAIR_IN6_ADDR_WITH_STRING("Prefix", &i->prefix),
                                SD_JSON_BUILD_PAIR_UNSIGNED("PrefixLength", i->prefix_len),
                                JSON_BUILD_PAIR_FINITE_USEC("LifetimeUSec", i->lifetime_usec),
                                JSON_BUILD_PAIR_IN6_ADDR_WITH_STRING_NON_NULL("ConfigProvider", &i->router));
                if (r < 0)
                        return r;
        }
 
        r = json_variant_set_field_non_null(&w, "PREF64", array);
        if (r < 0)
                return r;
 
        return json_variant_set_field_non_null(v, "NDisc", w);
}
 
static int dhcp_server_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
        int r;
 
        assert(link);
        assert(v);
 
        if (!link->dhcp_server)
                return 0;
 
        r = sd_json_buildo(
                        &w,
                        SD_JSON_BUILD_PAIR_UNSIGNED("PoolOffset", link->dhcp_server->pool_offset),
                        SD_JSON_BUILD_PAIR_UNSIGNED("PoolSize", link->dhcp_server->pool_size));
        if (r < 0)
                return r;
 
        r = dhcp_server_bound_leases_append_json(link->dhcp_server, &w);
        if (r < 0)
                return r;
 
        r = dhcp_server_static_leases_append_json(link->dhcp_server, &w);
        if (r < 0)
                return r;
 
        return json_variant_set_field_non_null(v, "DHCPServer", w);
}
 
static int dhcp6_client_vendor_options_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
        sd_dhcp6_option **options = NULL;
        int r, n_vendor_options;
 
        assert(link);
        assert(v);
 
        if (!link->dhcp6_lease)
                return 0;
 
        n_vendor_options = sd_dhcp6_lease_get_vendor_options(link->dhcp6_lease, &options);
 
        FOREACH_ARRAY(option, options, n_vendor_options) {
                r = sd_json_variant_append_arraybo(
                                &array,
                                SD_JSON_BUILD_PAIR_UNSIGNED("EnterpriseId", (*option)->enterprise_identifier),
                                SD_JSON_BUILD_PAIR_UNSIGNED("SubOptionCode", (*option)->option),
                                SD_JSON_BUILD_PAIR_HEX("SubOptionData", (*option)->data, (*option)->length));
                if (r < 0)
                        return r;
        }
 
        return json_variant_set_field_non_null(v, "VendorSpecificOptions", array);
}
 
static int dhcp6_client_lease_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
        usec_t ts = USEC_INFINITY, t1 = USEC_INFINITY, t2 = USEC_INFINITY;
        int r;
 
        assert(link);
        assert(v);
 
        if (!link->dhcp6_lease)
                return 0;
 
        r = sd_dhcp6_lease_get_timestamp(link->dhcp6_lease, CLOCK_BOOTTIME, &ts);
        if (r < 0 && r != -ENODATA)
                return r;
 
        r = sd_dhcp6_lease_get_t1_timestamp(link->dhcp6_lease, CLOCK_BOOTTIME, &t1);
        if (r < 0 && r != -ENODATA)
                return r;
 
        r = sd_dhcp6_lease_get_t2_timestamp(link->dhcp6_lease, CLOCK_BOOTTIME, &t2);
        if (r < 0 && r != -ENODATA)
                return r;
 
        r = sd_json_buildo(
                        &w,
                        JSON_BUILD_PAIR_FINITE_USEC("Timeout1USec", t1),
                        JSON_BUILD_PAIR_FINITE_USEC("Timeout2USec", t2),
                        JSON_BUILD_PAIR_FINITE_USEC("LeaseTimestampUSec", ts));
        if (r < 0)
                return r;
 
        return json_variant_set_field_non_null(v, "Lease", w);
}
 
static int dhcp6_client_pd_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
        int r;
 
        assert(link);
        assert(link->network);
        assert(v);
 
        if (!link->network->dhcp6_use_pd_prefix ||
            !sd_dhcp6_lease_has_pd_prefix(link->dhcp6_lease))
                return 0;
 
        FOREACH_DHCP6_PD_PREFIX(link->dhcp6_lease) {
                usec_t lifetime_preferred_usec, lifetime_valid_usec;
                struct in6_addr prefix;
                uint8_t prefix_len;
                _cleanup_free_ char *prefix_str = NULL;
 
                r = sd_dhcp6_lease_get_pd_prefix(link->dhcp6_lease, &prefix, &prefix_len);
                if (r < 0)
                        return r;
 
                r = sd_dhcp6_lease_get_pd_lifetime_timestamp(link->dhcp6_lease, CLOCK_BOOTTIME,
                                                             &lifetime_preferred_usec, &lifetime_valid_usec);
                if (r < 0)
                        return r;
 
                if (in6_addr_is_set(&prefix)) {
                        r = in6_addr_to_string(&prefix, &prefix_str);
                        if (r < 0)
                                return r;
                }
 
                r = sd_json_variant_append_arraybo(
                                &array,
                                JSON_BUILD_PAIR_IN6_ADDR("Prefix", &prefix),
                                JSON_BUILD_PAIR_STRING_NON_EMPTY("PrefixString", prefix_str),
                                SD_JSON_BUILD_PAIR_UNSIGNED("PrefixLength", prefix_len),
                                JSON_BUILD_PAIR_FINITE_USEC("PreferredLifetimeUSec", lifetime_preferred_usec),
                                JSON_BUILD_PAIR_FINITE_USEC("ValidLifetimeUSec", lifetime_valid_usec));
                if (r < 0)
                        return r;
        }
 
        return json_variant_set_field_non_null(v, "Prefixes", array);
}
 
static int dhcp6_client_duid_append_json(Link *link, sd_json_variant **v) {
        const sd_dhcp_duid *duid;
        const void *data;
        size_t data_size;
        int r;
 
        assert(link);
        assert(v);
 
        if (!link->dhcp6_client)
                return 0;
 
        r = sd_dhcp6_client_get_duid(link->dhcp6_client, &duid);
        if (r < 0)
                return 0;
 
        r = sd_dhcp_duid_get_raw(duid, &data, &data_size);
        if (r < 0)
                return 0;
 
        return sd_json_variant_merge_objectbo(v, SD_JSON_BUILD_PAIR_BYTE_ARRAY("DUID", data, data_size));
}
 
static int dhcp6_client_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
        int r;
 
        assert(link);
        assert(v);
 
        if (!link->dhcp6_client)
                return 0;
 
        r = dhcp6_client_lease_append_json(link, &w);
        if (r < 0)
                return r;
 
        r = dhcp6_client_pd_append_json(link, &w);
        if (r < 0)
                return r;
 
        r = dhcp6_client_vendor_options_append_json(link, &w);
        if (r < 0)
                return r;
 
        r = dhcp6_client_duid_append_json(link, &w);
        if (r < 0)
                return r;
 
        return json_variant_set_field_non_null(v, "DHCPv6Client", w);
}
 
static int dhcp_client_lease_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
        usec_t lease_timestamp_usec = USEC_INFINITY, t1 = USEC_INFINITY, t2 = USEC_INFINITY;
        const char *hostname = NULL;
        int r;
 
        assert(link);
        assert(v);
 
        if (!link->dhcp_client || !link->dhcp_lease)
                return 0;
 
        r = sd_dhcp_lease_get_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &lease_timestamp_usec);
        if (r < 0 && r != -ENODATA)
                return r;
 
        r = sd_dhcp_lease_get_t1_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &t1);
        if (r < 0 && r != -ENODATA)
                return r;
 
        r = sd_dhcp_lease_get_t2_timestamp(link->dhcp_lease, CLOCK_BOOTTIME, &t2);
        if (r < 0 && r != -ENODATA)
                return r;
 
        r = sd_dhcp_lease_get_hostname(link->dhcp_lease, &hostname);
        if (r < 0 && r != -ENODATA)
                return r;
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
        r = dhcp_message_build_json(link->dhcp_lease->message, &m);
        if (r < 0)
                return r;
 
        r = sd_json_buildo(
                        &w,
                        JSON_BUILD_PAIR_FINITE_USEC("LeaseTimestampUSec", lease_timestamp_usec),
                        JSON_BUILD_PAIR_FINITE_USEC("Timeout1USec", t1),
                        JSON_BUILD_PAIR_FINITE_USEC("Timeout2USec", t2),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("Hostname", hostname),
                        JSON_BUILD_PAIR_VARIANT_NON_NULL("Message", m));
        if (r < 0)
                return r;
 
        return json_variant_set_field_non_null(v, "Lease", w);
}
 
static int dhcp_client_pd_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *addresses = NULL, *array = NULL;
        uint8_t ipv4masklen, sixrd_prefixlen;
        struct in6_addr sixrd_prefix;
        const struct in_addr *br_addresses;
        size_t n_br_addresses = 0;
        _cleanup_free_ char *prefix_str = NULL;
        int r;
 
        assert(link);
        assert(link->network);
        assert(v);
 
        if (!link->network->dhcp_use_6rd || !sd_dhcp_lease_has_6rd(link->dhcp_lease))
                return 0;
 
        r = sd_dhcp_lease_get_6rd(link->dhcp_lease, &ipv4masklen, &sixrd_prefixlen, &sixrd_prefix, &br_addresses, &n_br_addresses);
        if (r < 0)
                return r;
 
        if (in6_addr_is_set(&sixrd_prefix)) {
                r = in6_addr_to_string(&sixrd_prefix, &prefix_str);
                if (r < 0)
                        return r;
        }
 
        FOREACH_ARRAY(br_address, br_addresses, n_br_addresses) {
                r = sd_json_variant_append_arrayb(&addresses, JSON_BUILD_IN4_ADDR(br_address));
                if (r < 0)
                        return r;
        }
 
        r = sd_json_buildo(
                        &array,
                        JSON_BUILD_PAIR_IN6_ADDR("Prefix", &sixrd_prefix),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("PrefixString", prefix_str),
                        SD_JSON_BUILD_PAIR_UNSIGNED("PrefixLength", sixrd_prefixlen),
                        SD_JSON_BUILD_PAIR_UNSIGNED("IPv4MaskLength", ipv4masklen),
                        JSON_BUILD_PAIR_VARIANT_NON_NULL("BorderRouters", addresses));
        if (r < 0)
                return r;
 
        return json_variant_set_field_non_null(v, "6rdPrefix", array);
}
 
static int dhcp_client_private_options_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
        int r;
 
        assert(link);
        assert(v);
 
        if (!link->dhcp_lease)
                return 0;
 
        for (uint8_t i = SD_DHCP_OPTION_PRIVATE_BASE; i <= SD_DHCP_OPTION_PRIVATE_LAST; i++) {
                _cleanup_(iovec_done) struct iovec iov = {};
                r = dhcp_message_get_option_alloc(link->dhcp_lease->message, i, &iov);
                if (r == -ENODATA)
                        continue;
                if (r < 0)
                        return r;
 
                r = sd_json_variant_append_arraybo(
                                &array,
                                SD_JSON_BUILD_PAIR_UNSIGNED("Option", i),
                                SD_JSON_BUILD_PAIR_HEX("PrivateOptionData", iov.iov_base, iov.iov_len));
                if (r < 0)
                        return r;
        }
 
        return json_variant_set_field_non_null(v, "PrivateOptions", array);
}
 
static int dhcp_client_id_append_json(Link *link, sd_json_variant **v) {
        assert(link);
        assert(v);
 
        if (!link->dhcp_client)
                return 0;
 
        const sd_dhcp_client_id *client_id;
        if (sd_dhcp_client_get_client_id(link->dhcp_client, &client_id) < 0)
                return 0;
 
        const void *data;
        size_t l;
        if (sd_dhcp_client_id_get_raw(client_id, &data, &l) < 0)
                return 0;
 
        return sd_json_variant_merge_objectbo(v, SD_JSON_BUILD_PAIR_BYTE_ARRAY("ClientIdentifier", data, l));
}
 
static int dhcp_client_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
        int r;
 
        assert(link);
        assert(v);
 
        if (!link->dhcp_client)
                return 0;
 
        r = dhcp_client_lease_append_json(link, &w);
        if (r < 0)
                return r;
 
        r = dhcp_client_pd_append_json(link, &w);
        if (r < 0)
                return r;
 
        r = dhcp_client_private_options_append_json(link, &w);
        if (r < 0)
                return r;
 
        r = dhcp_client_id_append_json(link, &w);
        if (r < 0)
                return r;
 
        return json_variant_set_field_non_null(v, "DHCPv4Client", w);
}
 
static int lldp_tx_append_json(Link *link, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
        int r;
 
        assert(link);
        assert(v);
 
        if (!link->lldp_tx)
                return 0;
 
        r = sd_lldp_tx_describe(link->lldp_tx, &w);
        if (r < 0)
                return r;
 
        return json_variant_set_field_non_null(v, "LLDP", w);
}
 
int link_build_json(Link *link, sd_json_variant **ret) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        _cleanup_free_ char *type = NULL, *flags = NULL;
        int r;
 
        assert(link);
        assert(ret);
 
        r = net_get_type_string(link->dev, link->iftype, &type);
        if (r == -ENOMEM)
                return r;
 
        r = link_flags_to_string_alloc(link->flags, &flags);
        if (r < 0)
                return r;
 
        r = sd_json_buildo(
                        &v,
                        /* basic information */
                        SD_JSON_BUILD_PAIR_INTEGER("Index", link->ifindex),
                        SD_JSON_BUILD_PAIR_STRING("Name", link->ifname),
                        JSON_BUILD_PAIR_STRV_NON_EMPTY("AlternativeNames", link->alternative_names),
                        SD_JSON_BUILD_PAIR_CONDITION(link->master_ifindex > 0,
                                                     "MasterInterfaceIndex", SD_JSON_BUILD_INTEGER(link->master_ifindex)),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("Kind", link->kind),
                        SD_JSON_BUILD_PAIR_STRING("Type", type),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("Driver", link->driver),
                        SD_JSON_BUILD_PAIR_UNSIGNED("Flags", link->flags),
                        SD_JSON_BUILD_PAIR_STRING("FlagsString", flags),
                        SD_JSON_BUILD_PAIR_UNSIGNED("KernelOperationalState", link->kernel_operstate),
                        SD_JSON_BUILD_PAIR_STRING("KernelOperationalStateString", kernel_operstate_to_string(link->kernel_operstate)),
                        SD_JSON_BUILD_PAIR_UNSIGNED("MTU", link->mtu),
                        SD_JSON_BUILD_PAIR_UNSIGNED("MinimumMTU", link->min_mtu),
                        SD_JSON_BUILD_PAIR_UNSIGNED("MaximumMTU", link->max_mtu),
                        JSON_BUILD_PAIR_HW_ADDR_NON_NULL("HardwareAddress", &link->hw_addr),
                        JSON_BUILD_PAIR_HW_ADDR_NON_NULL("PermanentHardwareAddress", &link->permanent_hw_addr),
                        JSON_BUILD_PAIR_HW_ADDR_NON_NULL("BroadcastAddress", &link->bcast_addr),
                        JSON_BUILD_PAIR_IN6_ADDR_WITH_STRING_NON_NULL("IPv6LinkLocalAddress", &link->ipv6ll_address),
                        /* wlan information */
                        SD_JSON_BUILD_PAIR_CONDITION(link->wlan_iftype > 0, "WirelessLanInterfaceType",
                                                     SD_JSON_BUILD_UNSIGNED(link->wlan_iftype)),
                        SD_JSON_BUILD_PAIR_CONDITION(link->wlan_iftype > 0, "WirelessLanInterfaceTypeString",
                                                     SD_JSON_BUILD_STRING(nl80211_iftype_to_string(link->wlan_iftype))),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("SSID", link->ssid),
                        JSON_BUILD_PAIR_ETHER_ADDR_NON_NULL("BSSID", &link->bssid),
                        /* link state */
                        SD_JSON_BUILD_PAIR_STRING("AdministrativeState", link_state_to_string(link->state)),
                        SD_JSON_BUILD_PAIR_STRING("OperationalState", link_operstate_to_string(link->operstate)),
                        SD_JSON_BUILD_PAIR_STRING("CarrierState", link_carrier_state_to_string(link->carrier_state)),
                        JSON_BUILD_PAIR_ENUM("AddressState", link_address_state_to_string(link->address_state)),
                        JSON_BUILD_PAIR_ENUM("IPv4AddressState", link_address_state_to_string(link->ipv4_address_state)),
                        JSON_BUILD_PAIR_ENUM("IPv6AddressState", link_address_state_to_string(link->ipv6_address_state)),
                        JSON_BUILD_PAIR_ENUM("OnlineState", link_online_state_to_string(link->online_state)));
        if (r < 0)
                return r;
 
        r = network_append_json(link->network, &v);
        if (r < 0)
                return r;
 
        r = netdev_append_json(link->netdev, &v);
        if (r < 0)
                return r;
 
        r = device_append_json(link->dev, &v);
        if (r < 0)
                return r;
 
        r = dns_append_json(link, &v);
        if (r < 0)
                return r;
 
        r = dnr_append_json(link, &v);
        if (r < 0)
                return r;
 
        r = ntp_append_json(link, &v);
        if (r < 0)
                return r;
 
        r = sip_append_json(link, &v);
        if (r < 0)
                return r;
 
        r = domains_append_json(link, /* is_route= */ false, &v);
        if (r < 0)
                return r;
 
        r = domains_append_json(link, /* is_route= */ true, &v);
        if (r < 0)
                return r;
 
        r = ntas_append_json(link, &v);
        if (r < 0)
                return r;
 
        r = dns_misc_append_json(link, &v);
        if (r < 0)
                return r;
 
        r = captive_portal_append_json(link, &v);
        if (r < 0)
                return r;
 
        r = pref64_append_json(link, &v);
        if (r < 0)
                return r;
 
        r = addresses_append_json(link, /* serializing= */ false, &v);
        if (r < 0)
                return r;
 
        r = neighbors_append_json(link->neighbors, &v);
        if (r < 0)
                return r;
 
        r = nexthops_append_json(link->manager, link->ifindex, &v);
        if (r < 0)
                return r;
 
        r = routes_append_json(link->manager, link->ifindex, &v);
        if (r < 0)
                return r;
 
        r = dhcp_server_append_json(link, &v);
        if (r < 0)
                return r;
 
        r = dhcp_client_append_json(link, &v);
        if (r < 0)
                return r;
 
        r = dhcp6_client_append_json(link, &v);
        if (r < 0)
                return r;
 
        r = lldp_tx_append_json(link, &v);
        if (r < 0)
                return r;
 
        /* Append BitRates if speed meter is active */
        uint64_t tx, rx;
        link_get_bit_rates(link, &tx, &rx);
        if (tx != UINT64_MAX && rx != UINT64_MAX) {
                r = sd_json_variant_merge_objectbo(
                                &v,
                                SD_JSON_BUILD_PAIR("BitRates",
                                        SD_JSON_BUILD_OBJECT(
                                                SD_JSON_BUILD_PAIR_UNSIGNED("TxBitRate", tx),
                                                SD_JSON_BUILD_PAIR_UNSIGNED("RxBitRate", rx))));
                if (r < 0)
                        return r;
        }
 
        *ret = TAKE_PTR(v);
        return 0;
}
 
static int links_append_json(Manager *manager, sd_json_variant **v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
        _cleanup_free_ Link **links = NULL;
        size_t n_links = 0;
        int r;
 
        assert(manager);
        assert(v);
 
        r = hashmap_dump_sorted(manager->links_by_index, (void***) &links, &n_links);
        if (r < 0)
                return r;
 
        FOREACH_ARRAY(link, links, n_links) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *e = NULL;
 
                r = link_build_json(*link, &e);
                if (r < 0)
                        return r;
 
                r = sd_json_variant_append_array(&array, e);
                if (r < 0)
                        return r;
        }
 
        return json_variant_set_field_non_null(v, "Interfaces", array);
}
 
int manager_build_json(Manager *manager, sd_json_variant **ret) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        int r;
 
        assert(manager);
        assert(ret);
 
        r = links_append_json(manager, &v);
        if (r < 0)
                return r;
 
        r = nexthops_append_json(manager, /* ifindex= */ 0, &v);
        if (r < 0)
                return r;
 
        r = routes_append_json(manager, /* ifindex= */ 0, &v);
        if (r < 0)
                return r;
 
        r = routing_policy_rules_append_json(manager->rules, &v);
        if (r < 0)
                return r;
 
        *ret = TAKE_PTR(v);
        return 0;
}