HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/resolve/resolved-varlink.c

63,000 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 5d5cdc172bf751141c1f80e238df65b1b16b6f95

Lines 1001–1589 of 1,589

 
        if (p.name && !p.type) /* Service name cannot be specified without service type. */
                return sd_varlink_error_invalid_parameter(link, JSON_VARIANT_STRING_CONST("type"));
 
        if (validate_and_mangle_query_flags(m, &p.flags, p.name, SD_RESOLVED_NO_TXT|SD_RESOLVED_NO_ADDRESS) < 0)
                return sd_varlink_error_invalid_parameter(link, JSON_VARIANT_STRING_CONST("flags"));
 
        /* Refuse the method if SRV is filtered. */
        if (set_contains(m->refuse_record_types, INT_TO_PTR(DNS_TYPE_SRV)))
                return sd_varlink_error(link, "io.systemd.Resolve.QueryRefused", NULL);
 
        r = dns_question_new_service(&question_utf8, p.name, p.type, p.domain, !(p.flags & SD_RESOLVED_NO_TXT), false);
        if (r < 0)
                return r;
 
        r = dns_question_new_service(&question_idna, p.name, p.type, p.domain, !(p.flags & SD_RESOLVED_NO_TXT), true);
        if (r < 0)
                return r;
 
        r = dns_query_new_for_varlink(m, &q, question_utf8, question_idna, NULL, p.ifindex, p.flags|SD_RESOLVED_NO_SEARCH, link);
        if (r < 0)
                return r;
 
        q->varlink_request = sd_varlink_ref(link);
        q->request_family = p.family;
        q->complete = vl_method_resolve_service_complete;
 
        sd_varlink_set_userdata(link, q);
 
        r = dns_query_go(q);
        if (r < 0)
                return r;
 
        TAKE_PTR(q);
        return 1;
}
 
static void vl_method_resolve_record_complete(DnsQuery *query) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *array = NULL;
        _cleanup_(dns_query_freep) DnsQuery *q = query;
        DnsQuestion *question;
        int r;
 
        assert(q);
 
        if (q->state != DNS_TRANSACTION_SUCCESS)
                return (void) reply_query_state(q);
 
        r = dns_query_process_cname_many(q);
        if (r == -ELOOP)
                return (void) sd_varlink_error(q->varlink_request, "io.systemd.Resolve.CNAMELoop", NULL);
        if (r < 0)
                goto finish;
        if (r == DNS_QUERY_CNAME) {
                /* This was a cname, and the query was restarted. */
                TAKE_PTR(q);
                return;
        }
 
        question = dns_query_question_for_protocol(q, q->answer_protocol);
 
        unsigned added = 0;
        int ifindex;
        DnsResourceRecord *rr;
        DNS_ANSWER_FOREACH_IFINDEX(rr, ifindex, q->answer) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
 
                r = dns_question_matches_rr(question, rr, NULL);
                if (r < 0)
                        goto finish;
                if (r == 0)
                        continue;
 
                r = dns_resource_record_to_json(rr, &v);
                if (r < 0)
                        goto finish;
 
                r = dns_resource_record_to_wire_format(rr, /* canonical= */ false); /* don't use DNSSEC canonical format, since it removes casing, but we want that for DNS_SD compat */
                if (r < 0)
                        goto finish;
 
                r = sd_json_variant_append_arraybo(
                                &array,
                                SD_JSON_BUILD_PAIR_CONDITION(ifindex > 0, "ifindex", SD_JSON_BUILD_INTEGER(ifindex)),
                                SD_JSON_BUILD_PAIR_CONDITION(!!v, "rr", SD_JSON_BUILD_VARIANT(v)),
                                SD_JSON_BUILD_PAIR_BASE64("raw", rr->wire_format, rr->wire_format_size));
                if (r < 0)
                        goto finish;
 
                added++;
        }
 
        if (added <= 0)
                return (void) sd_varlink_error(q->varlink_request, "io.systemd.Resolve.NoSuchResourceRecord", NULL);
 
        r = sd_varlink_replybo(
                        q->varlink_request,
                        SD_JSON_BUILD_PAIR_VARIANT("rrs", array),
                        SD_JSON_BUILD_PAIR_INTEGER("flags", dns_query_reply_flags_make(q)));
finish:
        if (r < 0) {
                log_full_errno(ERRNO_IS_DISCONNECT(r) ? LOG_DEBUG : LOG_ERR, r, "Failed to send record reply: %m");
                (void) sd_varlink_error_errno(q->varlink_request, r);
        }
}
 
static int vl_method_resolve_record(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        static const sd_json_dispatch_field dispatch_table[] = {
                { "ifindex", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_ifindex,         offsetof(LookupParameters, ifindex), SD_JSON_RELAX     },
                { "name",    SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(LookupParameters, name),    SD_JSON_MANDATORY },
                { "class",   _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16,       offsetof(LookupParameters, class),   0                 },
                { "type",    _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16,       offsetof(LookupParameters, type),    SD_JSON_MANDATORY },
                { "flags",   _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64,       offsetof(LookupParameters, flags),   0                 },
                {}
        };
 
        _cleanup_(lookup_parameters_destroy) LookupParameters p = {
                .class = DNS_CLASS_IN,
                .type = _DNS_TYPE_INVALID,
        };
        _cleanup_(dns_query_freep) DnsQuery *q = NULL;
        Manager *m;
        int r;
 
        assert(link);
 
        if (sd_varlink_get_userdata(link))
                return -EBUSY;
 
        m = ASSERT_PTR(sd_varlink_server_get_userdata(sd_varlink_get_server(link)));
 
        if (FLAGS_SET(flags, SD_VARLINK_METHOD_ONEWAY))
                return -EINVAL;
 
        r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
        if (r != 0)
                return r;
 
        r = dns_name_is_valid(p.name);
        if (r < 0)
                return r;
        if (r == 0)
                return sd_varlink_error_invalid_parameter(link, JSON_VARIANT_STRING_CONST("name"));
 
        if (!dns_type_is_valid_query(p.type))
                return sd_varlink_error(link, "io.systemd.Resolve.ResourceRecordTypeInvalidForQuery", NULL);
        if (dns_type_is_zone_transfer(p.type))
                return sd_varlink_error(link, "io.systemd.Resolve.ZoneTransfersNotPermitted", NULL);
        if (dns_type_is_obsolete(p.type))
                return sd_varlink_error(link, "io.systemd.Resolve.ResourceRecordTypeObsolete", NULL);
 
        if (validate_and_mangle_query_flags(m, &p.flags, p.name, SD_RESOLVED_NO_SEARCH) < 0)
                return sd_varlink_error_invalid_parameter(link, JSON_VARIANT_STRING_CONST("flags"));
 
        _cleanup_(dns_question_unrefp) DnsQuestion *question = dns_question_new(1);
        if (!question)
                return -ENOMEM;
 
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
        key = dns_resource_key_new(p.class, p.type, p.name);
        if (!key)
                return -ENOMEM;
 
        r = dns_question_add(question, key, /* flags= */ 0);
        if (r < 0)
                return r;
 
        r = dns_query_new_for_varlink(m, &q, question, question, NULL, p.ifindex, p.flags|SD_RESOLVED_NO_SEARCH|SD_RESOLVED_CLAMP_TTL, link);
        if (r < 0)
                return r;
 
        q->varlink_request = sd_varlink_ref(link);
        sd_varlink_set_userdata(link, q);
        q->complete = vl_method_resolve_record_complete;
 
        r = dns_query_go(q);
        if (r < 0)
                return r;
 
        TAKE_PTR(q);
        return 1;
}
 
static int verify_polkit(sd_varlink *link, sd_json_variant *parameters, const char *action) {
        int r;
        Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
 
        assert(action);
 
        r = sd_varlink_dispatch(link, parameters, dispatch_table_polkit_only, /* userdata= */ NULL);
        if (r != 0)
                return r;
 
        return varlink_verify_polkit_async(
                                link,
                                m->bus,
                                action,
                                /* details= */ NULL,
                                &m->polkit_registry);
}
 
static int vl_method_browse_services(sd_varlink* link, sd_json_variant* parameters, sd_varlink_method_flags_t flags, void* userdata) {
        static const sd_json_dispatch_field dispatch_table[] = {
                { "domain",  SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(LookupParamatersBrowseServices, domain),  0 },
                { "type",    SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(LookupParamatersBrowseServices, type),    0 },
                { "ifindex", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_int,          offsetof(LookupParamatersBrowseServices, ifindex), 0 },
                { "flags",   _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint64,       offsetof(LookupParamatersBrowseServices, flags),   0 },
                {}
        };
 
        LookupParamatersBrowseServices p = {};
        Manager *m;
        int r = 0;
 
        assert(link);
        assert(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
 
        m = ASSERT_PTR(sd_varlink_server_get_userdata(sd_varlink_get_server(link)));
 
        r = sd_varlink_dispatch(link, parameters, dispatch_table, &p);
        if (r != 0)
                return r;
 
        if (validate_and_mangle_query_flags(m, &p.flags, /* name= */ NULL, /* ok= */ 0))
                return sd_varlink_error_invalid_parameter_name(link, "flags");
 
        r = dns_subscribe_browse_service(m, link, p.domain, p.type, p.ifindex, p.flags);
        if (r < 0)
                return sd_varlink_error_errno(link, r);
 
        return 1;
}
 
static int vl_method_subscribe_query_results(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
        int r;
 
        assert(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
 
        r = verify_polkit(link, parameters, "org.freedesktop.resolve1.subscribe-query-results");
        if (r <= 0)
                return r;
 
        /* Send a ready message to the connecting client, to indicate that we are now listinening, and all
         * queries issued after the point the client sees this will also be reported to the client. */
        r = sd_varlink_notifybo(link, SD_JSON_BUILD_PAIR_BOOLEAN("ready", true));
        if (r < 0)
                return log_error_errno(r, "Failed to report monitor to be established: %m");
 
        r = set_ensure_put(&m->varlink_query_results_subscription, NULL, link);
        if (r < 0)
                return log_error_errno(r, "Failed to add subscription to set: %m");
        sd_varlink_ref(link);
 
        log_debug("%u clients now attached for query result varlink notifications", set_size(m->varlink_query_results_subscription));
 
        return 1;
}
 
static int vl_method_dump_cache(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *list = NULL;
        Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
        int r;
 
        assert(link);
 
        r = verify_polkit(link, parameters, "org.freedesktop.resolve1.dump-cache");
        if (r <= 0)
                return r;
 
        LIST_FOREACH(scopes, s, m->dns_scopes) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
 
                r = dns_scope_to_json(s, /* with_cache= */ true, &j);
                if (r < 0)
                        return r;
 
                r = sd_json_variant_append_array(&list, j);
                if (r < 0)
                        return r;
        }
 
        if (!list) {
                r = sd_json_variant_new_array(&list, NULL, 0);
                if (r < 0)
                        return r;
        }
 
        return sd_varlink_replybo(link, SD_JSON_BUILD_PAIR_VARIANT("dump", list));
}
 
static int dns_server_dump_state_to_json_list(DnsServer *server, sd_json_variant **list) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
        int r;
 
        assert(list);
        assert(server);
 
        r = dns_server_dump_state_to_json(server, &j);
        if (r < 0)
                return r;
 
        return sd_json_variant_append_array(list, j);
}
 
static int vl_method_dump_server_state(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *list = NULL;
        Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
        Link *l;
        int r;
 
        r = verify_polkit(link, parameters, "org.freedesktop.resolve1.dump-server-state");
        if (r <= 0)
                return r;
 
        LIST_FOREACH(servers, server, m->dns_servers) {
                r = dns_server_dump_state_to_json_list(server, &list);
                if (r < 0)
                        return r;
        }
 
        LIST_FOREACH(servers, server, m->fallback_dns_servers) {
                r = dns_server_dump_state_to_json_list(server, &list);
                if (r < 0)
                        return r;
        }
 
        HASHMAP_FOREACH(l, m->links)
                LIST_FOREACH(servers, server, l->dns_servers) {
                        r = dns_server_dump_state_to_json_list(server, &list);
                        if (r < 0)
                                return r;
                }
 
        if (!list) {
                r = sd_json_variant_new_array(&list, NULL, 0);
                if (r < 0)
                        return r;
        }
 
        return sd_varlink_replybo(link, SD_JSON_BUILD_PAIR_VARIANT("dump", list));
}
 
static int vl_method_dump_statistics(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *j = NULL;
        Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
        int r;
 
        assert(link);
 
        r = verify_polkit(link, parameters, "org.freedesktop.resolve1.dump-statistics");
        if (r <= 0)
                return r;
 
        r = dns_manager_dump_statistics_json(m, &j);
        if (r < 0)
                return r;
 
        return sd_varlink_replyb(link, SD_JSON_BUILD_VARIANT(j));
}
 
static int vl_method_reset_statistics(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
        int r;
 
        r = verify_polkit(link, parameters, "org.freedesktop.resolve1.reset-statistics");
        if (r <= 0)
                return r;
 
        dns_manager_reset_statistics(m);
 
        return sd_varlink_replyb(link, SD_JSON_BUILD_EMPTY_OBJECT);
}
 
static int vl_method_flush_caches(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
        int r;
 
        r = verify_polkit(link, parameters, "org.freedesktop.resolve1.flush-caches");
        if (r <= 0)
                return r;
 
        manager_flush_caches(m, LOG_INFO);
 
        return sd_varlink_reply(link, NULL);
}
 
static int vl_method_reset_server_features(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
        int r;
 
        r = verify_polkit(link, parameters, "org.freedesktop.resolve1.reset-server-features");
        if (r <= 0)
                return r;
 
        (void) dns_stream_disconnect_all(m);
        manager_reset_server_features(m);
 
        return sd_varlink_reply(link, NULL);
}
 
static int vl_method_subscribe_dns_configuration(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        Manager *m = ASSERT_PTR(sd_varlink_get_userdata(ASSERT_PTR(link)));
        int r;
 
        assert(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
 
        r = verify_polkit(link, parameters, "org.freedesktop.resolve1.subscribe-dns-configuration");
        if (r <= 0)
                return r;
 
        if (set_isempty(m->varlink_dns_configuration_subscription)) {
                r = manager_start_dns_configuration_monitor(m);
                if (r < 0)
                        return log_error_errno(r, "Failed to start DNS configuration monitor: %m");
        }
 
        r = sd_varlink_notify(link, m->dns_configuration_json);
        if (r < 0)
                goto fail;
 
        r = set_ensure_put(&m->varlink_dns_configuration_subscription, NULL, link);
        if (r < 0)
                goto fail;
        sd_varlink_ref(link);
 
        log_debug("%u clients now attached for link configuration varlink notifications",
                  set_size(m->varlink_dns_configuration_subscription));
 
        return 1;
fail:
        if (set_isempty(m->varlink_dns_configuration_subscription))
                manager_stop_dns_configuration_monitor(m);
 
        return log_debug_errno(r, "Failed to subscribe client to DNS configuration monitor: %m");
}
 
static int vl_method_dump_dns_configuration(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *configuration = NULL;
        Manager *m;
        Link *l;
        int r;
 
        assert(link);
 
        m = ASSERT_PTR(sd_varlink_server_get_userdata(sd_varlink_get_server(link)));
 
        /* Make sure the accessible flag is not stale. */
        dns_server_reset_accessible_all(m->dns_servers);
 
        HASHMAP_FOREACH(l, m->links)
                dns_server_reset_accessible_all(l->dns_servers);
 
        r = manager_dump_dns_configuration_json(m, &configuration);
        if (r < 0)
                return r;
 
        return sd_varlink_reply(link, configuration);
}
 
static int varlink_monitor_server_init(Manager *m) {
        _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *server = NULL;
        int r;
 
        assert(m);
 
        if (m->varlink_monitor_server)
                return 0;
 
        r = varlink_server_new(&server, SD_VARLINK_SERVER_ACCOUNT_UID|SD_VARLINK_SERVER_INHERIT_USERDATA, m);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate varlink server object: %m");
 
        r = sd_varlink_server_add_interface(server, &vl_interface_io_systemd_Resolve_Monitor);
        if (r < 0)
                return log_error_errno(r, "Failed to add Resolve.Monitor interface to varlink server: %m");
 
        r = sd_varlink_server_bind_method_many(
                        server,
                        "io.systemd.Resolve.Monitor.SubscribeQueryResults", vl_method_subscribe_query_results,
                        "io.systemd.Resolve.Monitor.DumpCache", vl_method_dump_cache,
                        "io.systemd.Resolve.Monitor.DumpServerState", vl_method_dump_server_state,
                        "io.systemd.Resolve.Monitor.DumpStatistics", vl_method_dump_statistics,
                        "io.systemd.Resolve.Monitor.ResetStatistics", vl_method_reset_statistics,
                        "io.systemd.Resolve.Monitor.SubscribeDNSConfiguration", vl_method_subscribe_dns_configuration,
                        "io.systemd.Resolve.Monitor.FlushCaches", vl_method_flush_caches,
                        "io.systemd.Resolve.Monitor.ResetServerFeatures", vl_method_reset_server_features);
        if (r < 0)
                return log_error_errno(r, "Failed to register varlink methods: %m");
 
        r = sd_varlink_server_bind_disconnect(server, vl_on_notification_disconnect);
        if (r < 0)
                return log_error_errno(r, "Failed to register varlink disconnect handler: %m");
 
        r = sd_varlink_server_listen_name(server, "varlink-monitor");
        if (r < 0)
                return log_error_errno(r, "Failed to get varlink listen fd: %m");
        if (r == 0) {
                r = sd_varlink_server_listen_address(server, "/run/systemd/resolve/io.systemd.Resolve.Monitor", 0666);
                if (r < 0)
                        return log_error_errno(r, "Failed to bind to varlink socket '/run/systemd/resolve/io.systemd.Resolve.Monitor': %m");
        }
 
        r = sd_varlink_server_attach_event(server, m->event, SD_EVENT_PRIORITY_NORMAL);
        if (r < 0)
                return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
 
        m->varlink_monitor_server = TAKE_PTR(server);
 
        return 0;
}
 
static int varlink_main_server_init(Manager *m) {
        _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
        int r;
 
        assert(m);
 
        if (m->varlink_server)
                return 0;
 
        r = varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID, m);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate varlink server object: %m");
 
        r = sd_varlink_server_add_interface_many(
                        s,
                        &vl_interface_io_systemd_Resolve,
                        &vl_interface_io_systemd_service);
        if (r < 0)
                return log_error_errno(r, "Failed to add Resolve interface to varlink server: %m");
 
        r = sd_varlink_server_bind_method_many(
                        s,
                        "io.systemd.Resolve.ResolveHostname",      vl_method_resolve_hostname,
                        "io.systemd.Resolve.ResolveAddress",       vl_method_resolve_address,
                        "io.systemd.Resolve.ResolveService",       vl_method_resolve_service,
                        "io.systemd.Resolve.ResolveRecord",        vl_method_resolve_record,
                        "io.systemd.service.Ping",                 varlink_method_ping,
                        "io.systemd.service.SetLogLevel",          varlink_method_set_log_level,
                        "io.systemd.service.GetLogLevel",          varlink_method_get_log_level,
                        "io.systemd.service.GetEnvironment",       varlink_method_get_environment,
                        "io.systemd.Resolve.BrowseServices",       vl_method_browse_services,
                        "io.systemd.Resolve.DumpDNSConfiguration", vl_method_dump_dns_configuration);
        if (r < 0)
                return log_error_errno(r, "Failed to register varlink methods: %m");
 
        r = sd_varlink_server_bind_disconnect(s, vl_on_disconnect);
        if (r < 0)
                return log_error_errno(r, "Failed to register varlink disconnect handler: %m");
 
        r = sd_varlink_server_listen_auto(s);
        if (r < 0)
                return log_error_errno(r, "Failed to get varlink listen fd: %m");
        if (r == 0) {
                r = sd_varlink_server_listen_address(s, "/run/systemd/resolve/io.systemd.Resolve", 0666);
                if (r < 0)
                        return log_error_errno(r, "Failed to bind to varlink socket '/run/systemd/resolve/io.systemd.Resolve': %m");
        }
 
        r = sd_varlink_server_attach_event(s, m->event, SD_EVENT_PRIORITY_NORMAL);
        if (r < 0)
                return log_error_errno(r, "Failed to attach varlink connection to event loop: %m");
 
        m->varlink_server = TAKE_PTR(s);
        return 0;
}
 
int manager_varlink_init(Manager *m) {
        int r;
 
        r = varlink_main_server_init(m);
        if (r < 0)
                return r;
 
        r = varlink_monitor_server_init(m);
        if (r < 0)
                return r;
 
        return 0;
}
 
void manager_varlink_done(Manager *m) {
        assert(m);
 
        m->varlink_server = sd_varlink_server_unref(m->varlink_server);
        m->varlink_monitor_server = sd_varlink_server_unref(m->varlink_monitor_server);
}