/* SPDX-License-Identifier: LGPL-2.1+ */

#include "nm-default.h"

#include "nm-cloud-setup-utils.h"

#include <linux/if_ether.h>

#include <linux/if_infiniband.h>

#include "nm-glib-aux/nm-time-utils.h"

#include "nm-glib-aux/nm-logging-base.h"

#include "nm-glib-aux/nm-str-buf.h"

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

volatile NMLogLevel _nm_logging_configured_level = LOGL_TRACE;

void

_nm_logging_enabled_init(const char *level_str)

{

    NMLogLevel level;

    if (!_nm_log_parse_level(level_str, &level))

        level = LOGL_WARN;

    else if (level == _LOGL_KEEP)

        level = LOGL_WARN;

    _nm_logging_configured_level = level;

}

void

_nm_log_impl_cs(NMLogLevel level, const char *fmt, ...)

{

    gs_free char *msg = NULL;

    va_list       ap;

    const char *  level_str;

    gint64        ts;

    va_start(ap, fmt);

    msg = g_strdup_vprintf(fmt, ap);

    va_end(ap);

    switch (level) {

    case LOGL_TRACE:

        level_str = "<trace>";

        break;

    case LOGL_DEBUG:

        level_str = "<debug>";

        break;

    case LOGL_INFO:

        level_str = "<info> ";

        break;

    case LOGL_WARN:

        level_str = "<warn> ";

        break;

    default:

        nm_assert(level == LOGL_ERR);

        level_str = "<error>";

        break;

    }

    ts = nm_utils_clock_gettime_nsec(CLOCK_BOOTTIME);

    g_print("[%" G_GINT64_FORMAT ".%05" G_GINT64_FORMAT "] %s %s\n",

            ts / NM_UTILS_NSEC_PER_SEC,

            (ts / (NM_UTILS_NSEC_PER_SEC / 10000)) % 10000,

            level_str,

            msg);

}

void

_nm_utils_monotonic_timestamp_initialized(const struct timespec *tp,

                                          gint64                 offset_sec,

                                          gboolean               is_boottime)

{}

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

G_LOCK_DEFINE_STATIC(_wait_for_objects_lock);

static GSList *_wait_for_objects_list;

static GSList *_wait_for_objects_iterate_loops;

static void

_wait_for_objects_maybe_quit_mainloops_with_lock(void)

{

    GSList *iter;

    if (!_wait_for_objects_list) {

        for (iter = _wait_for_objects_iterate_loops; iter; iter = iter->next)

            g_main_loop_quit(iter->data);

    }

}

static void

_wait_for_objects_weak_cb(gpointer data, GObject *where_the_object_was)

{

    G_LOCK(_wait_for_objects_lock);

    nm_assert(g_slist_find(_wait_for_objects_list, where_the_object_was));

    _wait_for_objects_list = g_slist_remove(_wait_for_objects_list, where_the_object_was);

    _wait_for_objects_maybe_quit_mainloops_with_lock();

    G_UNLOCK(_wait_for_objects_lock);

}

/**

 * nmcs_wait_for_objects_register:

 * @target: a #GObject to wait for.

 *

 * Registers @target as a pointer to wait during shutdown. Using

 * nmcs_wait_for_objects_iterate_until_done() we keep waiting until

 * @target gets destroyed, which means that it gets completely unreferenced.

 */

gpointer

nmcs_wait_for_objects_register(gpointer target)

{

    g_return_val_if_fail(G_IS_OBJECT(target), NULL);

    G_LOCK(_wait_for_objects_lock);

    _wait_for_objects_list = g_slist_prepend(_wait_for_objects_list, target);

    G_UNLOCK(_wait_for_objects_lock);

    g_object_weak_ref(target, _wait_for_objects_weak_cb, NULL);

    return target;

}

typedef struct {

    GMainLoop *loop;

    gboolean   got_timeout;

} WaitForObjectsData;

static gboolean

_wait_for_objects_iterate_until_done_timeout_cb(gpointer user_data)

{

    WaitForObjectsData *data = user_data;

    data->got_timeout = TRUE;

    g_main_loop_quit(data->loop);

    return G_SOURCE_CONTINUE;

}

static gboolean

_wait_for_objects_iterate_until_done_idle_cb(gpointer user_data)

{

    /* This avoids a race where:

     *

     *   - we check whether there are objects to wait for.

     *   - the last object to wait for gets removed (issuing g_main_loop_quit()).

     *   - we run the mainloop (and missed our signal).

     *

     * It's really a missing feature of GMainLoop where the "is-running" flag is always set to

     * TRUE by g_main_loop_run(). That means, you cannot catch a g_main_loop_quit() in a race

     * free way while not iterating the loop.

     *

     * Avoid this, by checking once again after we start running the mainloop.

     */

    G_LOCK(_wait_for_objects_lock);

    _wait_for_objects_maybe_quit_mainloops_with_lock();

    G_UNLOCK(_wait_for_objects_lock);

    return G_SOURCE_REMOVE;

}

/**

 * nmcs_wait_for_objects_iterate_until_done:

 * @context: the #GMainContext to iterate.

 * @timeout_msec: timeout or -1 for no timeout.

 *

 * Iterates the provided @context until all objects that we wait for

 * are destroyed.

 *

 * The purpose of this is to cleanup all objects that we have on exit. That

 * is especially because objects have asynchronous operations pending that

 * should be cancelled and properly completed during exit.

 *

 * Returns: %FALSE on timeout or %TRUE if all objects destroyed before timeout.

 */

gboolean

nmcs_wait_for_objects_iterate_until_done(GMainContext *context, int timeout_msec)

{

    nm_auto_unref_gmainloop GMainLoop *loop                   = g_main_loop_new(context, FALSE);

    nm_auto_destroy_and_unref_gsource GSource *timeout_source = NULL;

    WaitForObjectsData                         data;

    gboolean                                   has_more_objects;

    G_LOCK(_wait_for_objects_lock);

    if (!_wait_for_objects_list) {

        G_UNLOCK(_wait_for_objects_lock);

        return TRUE;

    }

    _wait_for_objects_iterate_loops = g_slist_prepend(_wait_for_objects_iterate_loops, loop);

    G_UNLOCK(_wait_for_objects_lock);

    data = (WaitForObjectsData){

        .loop        = loop,

        .got_timeout = FALSE,

    };

    if (timeout_msec >= 0) {

        timeout_source = nm_g_source_attach(

            nm_g_timeout_source_new(timeout_msec,

                                    G_PRIORITY_DEFAULT,

                                    _wait_for_objects_iterate_until_done_timeout_cb,

                                    &data,

                                    NULL),

            context);

    }

    has_more_objects = TRUE;

    while (has_more_objects && !data.got_timeout) {

        nm_auto_destroy_and_unref_gsource GSource *idle_source = NULL;

        idle_source =

            nm_g_source_attach(nm_g_idle_source_new(G_PRIORITY_DEFAULT,

                                                    _wait_for_objects_iterate_until_done_idle_cb,

                                                    &data,

                                                    NULL),

                               context);

        g_main_loop_run(loop);

        G_LOCK(_wait_for_objects_lock);

        has_more_objects = (!!_wait_for_objects_list);

        if (data.got_timeout || !has_more_objects)

            _wait_for_objects_iterate_loops = g_slist_remove(_wait_for_objects_iterate_loops, loop);

        G_UNLOCK(_wait_for_objects_lock);

    }

    return !data.got_timeout;

}

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

typedef struct {

    GTask *                     task;

    GSource *                   source_timeout;

    GSource *                   source_next_poll;

    GMainContext *              context;

    GCancellable *              internal_cancellable;

    NMCSUtilsPollProbeStartFcn  probe_start_fcn;

    NMCSUtilsPollProbeFinishFcn probe_finish_fcn;

    gpointer                    probe_user_data;

    gulong                      cancellable_id;

    gint64                      last_poll_start_ms;

    int                         sleep_timeout_ms;

    int                         ratelimit_timeout_ms;

    bool                        completed : 1;

} PollTaskData;

static void

_poll_task_data_free(gpointer data)

{

    PollTaskData *poll_task_data = data;

    nm_assert(G_IS_TASK(poll_task_data->task));

    nm_assert(!poll_task_data->source_next_poll);

    nm_assert(!poll_task_data->source_timeout);

    nm_assert(poll_task_data->cancellable_id == 0);

    g_main_context_unref(poll_task_data->context);

    nm_g_slice_free(poll_task_data);

}

static void

_poll_return(PollTaskData *poll_task_data, GError *error_take)

{

    nm_clear_g_source_inst(&poll_task_data->source_next_poll);

    nm_clear_g_source_inst(&poll_task_data->source_timeout);

    nm_clear_g_cancellable_disconnect(g_task_get_cancellable(poll_task_data->task),

                                      &poll_task_data->cancellable_id);

    nm_clear_g_cancellable(&poll_task_data->internal_cancellable);

    if (error_take)

        g_task_return_error(poll_task_data->task, g_steal_pointer(&error_take));

    else

        g_task_return_boolean(poll_task_data->task, TRUE);

    g_object_unref(poll_task_data->task);

}

static gboolean _poll_start_cb(gpointer user_data);

static void

_poll_done_cb(GObject *source, GAsyncResult *result, gpointer user_data)

{

    PollTaskData *             poll_task_data = user_data;

    _nm_unused gs_unref_object GTask *task =

        poll_task_data->task; /* balance ref from _poll_start_cb() */

    gs_free_error GError *error = NULL;

    gint64                now_ms;

    gint64                wait_ms;

    gboolean              is_finished;

    is_finished =

        poll_task_data->probe_finish_fcn(source, result, poll_task_data->probe_user_data, &error);

    if (nm_utils_error_is_cancelled(error)) {

        /* we already handle this differently. Nothing to do. */

        return;

    }

    if (error || is_finished) {

        _poll_return(poll_task_data, g_steal_pointer(&error));

        return;

    }

    now_ms = nm_utils_get_monotonic_timestamp_msec();

    if (poll_task_data->ratelimit_timeout_ms > 0)

        wait_ms =

            (poll_task_data->last_poll_start_ms + poll_task_data->ratelimit_timeout_ms) - now_ms;

    else

        wait_ms = 0;

    if (poll_task_data->sleep_timeout_ms > 0)

        wait_ms = MAX(wait_ms, poll_task_data->sleep_timeout_ms);

    poll_task_data->source_next_poll =

        nm_g_source_attach(nm_g_timeout_source_new(MAX(1, wait_ms),

                                                   G_PRIORITY_DEFAULT,

                                                   _poll_start_cb,

                                                   poll_task_data,

                                                   NULL),

                           poll_task_data->context);

}

static gboolean

_poll_start_cb(gpointer user_data)

{

    PollTaskData *poll_task_data = user_data;

    nm_clear_g_source_inst(&poll_task_data->source_next_poll);

    poll_task_data->last_poll_start_ms = nm_utils_get_monotonic_timestamp_msec();

    g_object_ref(poll_task_data->task); /* balanced by _poll_done_cb() */

    poll_task_data->probe_start_fcn(poll_task_data->internal_cancellable,

                                    poll_task_data->probe_user_data,

                                    _poll_done_cb,

                                    poll_task_data);

    return G_SOURCE_CONTINUE;

}

static gboolean

_poll_timeout_cb(gpointer user_data)

{

    PollTaskData *poll_task_data = user_data;

    _poll_return(poll_task_data, nm_utils_error_new(NM_UTILS_ERROR_UNKNOWN, "timeout expired"));

    return G_SOURCE_CONTINUE;

}

static void

_poll_cancelled_cb(GObject *object, gpointer user_data)

{

    PollTaskData *poll_task_data = user_data;

    GError *      error          = NULL;

    nm_clear_g_signal_handler(g_task_get_cancellable(poll_task_data->task),

                              &poll_task_data->cancellable_id);

    nm_utils_error_set_cancelled(&error, FALSE, NULL);

    _poll_return(poll_task_data, error);

}

/**

 * nmcs_utils_poll:

 * @poll_timeout_ms: if >= 0, then this is the overall timeout for how long we poll.

 *   When this timeout expires, the request completes with failure (and error set).

 * @ratelimit_timeout_ms: if > 0, we ratelimit the starts from one prope_start_fcn

 *   call to the next.

 * @sleep_timeout_ms: if > 0, then we wait after a probe finished this timeout

 *   before the next. Together with @ratelimit_timeout_ms this determines how

 *   frequently we probe.

 * @probe_start_fcn: used to start a (asynchronous) probe. A probe must be completed

 *   by calling the provided callback. While a probe is in progress, we will not

 *   start another. This function is already invoked the first time synchronously,

 *   during nmcs_utils_poll().

 * @probe_finish_fcn: will be called from the callback of @probe_start_fcn. If the

 *   function returns %TRUE (polling done) or an error, polling stops. Otherwise,

 *   another poll will be started.

 * @probe_user_data: user_data for the probe functions.

 * @cancellable: cancellable for polling.

 * @callback: when polling completes.

 * @user_data: for @callback.

 *

 * This uses the current g_main_context_get_thread_default() for scheduling

 * actions.

 */

void

nmcs_utils_poll(int                         poll_timeout_ms,

                int                         ratelimit_timeout_ms,

                int                         sleep_timeout_ms,

                NMCSUtilsPollProbeStartFcn  probe_start_fcn,

                NMCSUtilsPollProbeFinishFcn probe_finish_fcn,

                gpointer                    probe_user_data,

                GCancellable *              cancellable,

                GAsyncReadyCallback         callback,

                gpointer                    user_data)

{

    PollTaskData *poll_task_data;

    poll_task_data  = g_slice_new(PollTaskData);

    *poll_task_data = (PollTaskData){

        .task             = nm_g_task_new(NULL, cancellable, nmcs_utils_poll, callback, user_data),

        .probe_start_fcn  = probe_start_fcn,

        .probe_finish_fcn = probe_finish_fcn,

        .probe_user_data  = probe_user_data,

        .completed        = FALSE,

        .context          = g_main_context_ref_thread_default(),

        .sleep_timeout_ms = sleep_timeout_ms,

        .ratelimit_timeout_ms = ratelimit_timeout_ms,

        .internal_cancellable = g_cancellable_new(),

    };

    nmcs_wait_for_objects_register(poll_task_data->task);

    g_task_set_task_data(poll_task_data->task, poll_task_data, _poll_task_data_free);

    if (poll_timeout_ms >= 0) {

        poll_task_data->source_timeout =

            nm_g_source_attach(nm_g_timeout_source_new(poll_timeout_ms,

                                                       G_PRIORITY_DEFAULT,

                                                       _poll_timeout_cb,

                                                       poll_task_data,

                                                       NULL),

                               poll_task_data->context);

    }

    poll_task_data->source_next_poll = nm_g_source_attach(

        nm_g_idle_source_new(G_PRIORITY_DEFAULT, _poll_start_cb, poll_task_data, NULL),

        poll_task_data->context);

    if (cancellable) {

        gulong signal_id;

        signal_id = g_cancellable_connect(cancellable,

                                          G_CALLBACK(_poll_cancelled_cb),

                                          poll_task_data,

                                          NULL);

        if (signal_id == 0) {

            /* the request is already cancelled. Return. */

            return;

        }

        poll_task_data->cancellable_id = signal_id;

    }

}

/**

 * nmcs_utils_poll_finish:

 * @result: the GAsyncResult from the GAsyncReadyCallback callback.

 * @probe_user_data: the user data provided to nmcs_utils_poll().

 * @error: the failure code.

 *

 * Returns: %TRUE if the polling completed with success. In that case,

 *   the error won't be set.

 *   If the request was cancelled, this is indicated by @error and

 *   %FALSE will be returned.

 *   If the probe returned a failure, this returns %FALSE and the error

 *   provided by @probe_finish_fcn.

 *   If the request times out, this returns %FALSE with error set.

 *   Error is always set if (and only if) the function returns %FALSE.

 */

gboolean

nmcs_utils_poll_finish(GAsyncResult *result, gpointer *probe_user_data, GError **error)

{

    GTask *       task;

    PollTaskData *poll_task_data;

    g_return_val_if_fail(nm_g_task_is_valid(result, NULL, nmcs_utils_poll), FALSE);

    g_return_val_if_fail(!error || !*error, FALSE);

    task = G_TASK(result);

    if (probe_user_data) {

        poll_task_data = g_task_get_task_data(task);

        NM_SET_OUT(probe_user_data, poll_task_data->probe_user_data);

    }

    return g_task_propagate_boolean(task, error);

}

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

char *

nmcs_utils_hwaddr_normalize(const char *hwaddr, gssize len)

{

    gs_free char *hwaddr_clone = NULL;

    guint8        buf[ETH_ALEN];

    nm_assert(len >= -1);

    if (len < 0) {

        if (!hwaddr)

            return NULL;

    } else {

        if (len == 0)

            return NULL;

        nm_assert(hwaddr);

        hwaddr = nm_strndup_a(300, hwaddr, len, &hwaddr_clone);

    }

    /* we cannot use _nm_utils_hwaddr_aton() because that requires a delimiter.

     * Azure exposes MAC addresses without delimiter, so accept that too. */

    if (!nm_utils_hexstr2bin_full(hwaddr,

                                  FALSE,

                                  FALSE,

                                  FALSE,

                                  ":-",

                                  sizeof(buf),

                                  buf,

                                  sizeof(buf),

                                  NULL))

        return NULL;

    return nm_utils_hwaddr_ntoa(buf, sizeof(buf));

}

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

const char *

nmcs_utils_parse_memmem(GBytes *mem, const char *needle)

{

    const char *mem_data;

    gsize       mem_size;

    g_return_val_if_fail(mem, NULL);

    g_return_val_if_fail(needle, NULL);

    mem_data = g_bytes_get_data(mem, &mem_size);

    return memmem(mem_data, mem_size, needle, strlen(needle));

}

const char *

nmcs_utils_parse_get_full_line(GBytes *mem, const char *needle)

{

    const char *mem_data;

    gsize       mem_size;

    gsize       c;

    gsize       l;

    const char *line;

    line = nmcs_utils_parse_memmem(mem, needle);

    if (!line)

        return NULL;

    mem_data = g_bytes_get_data(mem, &mem_size);

    if (line != mem_data && line[-1] != '\n') {

        /* the line must be preceeded either by the begin of the data or

         * by a newline. */

        return NULL;

    }

    c = mem_size - (line - mem_data);

    l = strlen(needle);

    if (c != l && line[l] != '\n') {

        /* the end of the needle must be either a newline or the end of the buffer. */

        return NULL;

    }

    return line;

}

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

char *

nmcs_utils_uri_build_concat_v(const char *base, const char **components, gsize n_components)

{

    NMStrBuf strbuf = NM_STR_BUF_INIT(NM_UTILS_GET_NEXT_REALLOC_SIZE_104, FALSE);

    nm_assert(base);

    nm_assert(base[0]);

    nm_assert(!NM_STR_HAS_SUFFIX(base, "/"));

    nm_str_buf_append(&strbuf, base);

    if (n_components > 0 && components[0] && components[0][0] == '/') {

        /* the first component starts with a slash. We allow that, and don't add a duplicate

         * slash. Otherwise, we add a separator after base.

         *

         * We only do that for the first component. */

    } else

        nm_str_buf_append_c(&strbuf, '/');

    while (n_components > 0) {

        if (!components[0]) {

            /* we allow NULL, to indicate nothing to append */

        } else

            nm_str_buf_append(&strbuf, components[0]);

        components++;

        n_components--;

    }

    return nm_str_buf_finalize(&strbuf, NULL);

}

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

gboolean

nmcs_setting_ip_replace_ipv4_addresses(NMSettingIPConfig *s_ip,

                                       NMIPAddress **     entries_arr,

                                       guint              entries_len)

{

    gboolean any_changes = FALSE;

    guint    i_next;

    guint    num;

    guint    i;

    num = nm_setting_ip_config_get_num_addresses(s_ip);

    i_next = 0;

    for (i = 0; i < entries_len; i++) {

        NMIPAddress *entry = entries_arr[i];

        if (!any_changes) {

            if (i_next < num) {

                if (nm_ip_address_cmp_full(entry,

                                           nm_setting_ip_config_get_address(s_ip, i_next),

                                           NM_IP_ADDRESS_CMP_FLAGS_WITH_ATTRS)

                    == 0) {

                    i_next++;

                    continue;

                }

            }

            while (i_next < num)

                nm_setting_ip_config_remove_address(s_ip, --num);

            any_changes = TRUE;

        }

        if (!nm_setting_ip_config_add_address(s_ip, entry))

            continue;

        i_next++;

    }

    if (any_changes) {

        while (i_next < num) {

            nm_setting_ip_config_remove_address(s_ip, --num);

            any_changes = TRUE;

        }

    }

    return any_changes;

}

gboolean

nmcs_setting_ip_replace_ipv4_routes(NMSettingIPConfig *s_ip,

                                    NMIPRoute **       entries_arr,

                                    guint              entries_len)

{

    gboolean any_changes = FALSE;

    guint    i_next;

    guint    num;

    guint    i;

    num = nm_setting_ip_config_get_num_routes(s_ip);

    i_next = 0;

    for (i = 0; i < entries_len; i++) {

        NMIPRoute *entry = entries_arr[i];

        if (!any_changes) {

            if (i_next < num) {

                if (nm_ip_route_equal_full(entry,

                                           nm_setting_ip_config_get_route(s_ip, i_next),

                                           NM_IP_ROUTE_EQUAL_CMP_FLAGS_WITH_ATTRS)) {

                    i_next++;

                    continue;

                }

            }

            while (i_next < num)

                nm_setting_ip_config_remove_route(s_ip, --num);

            any_changes = TRUE;

        }

        if (!nm_setting_ip_config_add_route(s_ip, entry))

            continue;

        i_next++;

    }

    if (!any_changes) {

        while (i_next < num) {

            nm_setting_ip_config_remove_route(s_ip, --num);

            any_changes = TRUE;

        }

    }

    return any_changes;

}

gboolean

nmcs_setting_ip_replace_ipv4_rules(NMSettingIPConfig *s_ip,

                                   NMIPRoutingRule ** entries_arr,

                                   guint              entries_len)

{

    gboolean any_changes = FALSE;

    guint    i_next;

    guint    num;

    guint    i;

    num = nm_setting_ip_config_get_num_routing_rules(s_ip);

    i_next = 0;

    for (i = 0; i < entries_len; i++) {

        NMIPRoutingRule *entry = entries_arr[i];

        if (!any_changes) {

            if (i_next < num) {

                if (nm_ip_routing_rule_cmp(entry,

                                           nm_setting_ip_config_get_routing_rule(s_ip, i_next))

                    == 0) {

                    i_next++;

                    continue;

                }

            }

            while (i_next < num)

                nm_setting_ip_config_remove_routing_rule(s_ip, --num);

            any_changes = TRUE;

        }

        nm_setting_ip_config_add_routing_rule(s_ip, entry);

        i_next++;

    }

    if (!any_changes) {

        while (i_next < num) {

            nm_setting_ip_config_remove_routing_rule(s_ip, --num);

            any_changes = TRUE;

        }

    }

    return any_changes;

}

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

typedef struct {

    GMainLoop *   main_loop;

    NMConnection *connection;

    GError *      error;

    guint64       version_id;

} DeviceGetAppliedConnectionData;

static void

_nmcs_device_get_applied_connection_cb(GObject *source, GAsyncResult *result, gpointer user_data)

{

    DeviceGetAppliedConnectionData *data = user_data;

    data->connection = nm_device_get_applied_connection_finish(NM_DEVICE(source),

                                                               result,

                                                               &data->version_id,

                                                               &data->error);

    g_main_loop_quit(data->main_loop);

}

NMConnection *

nmcs_device_get_applied_connection(NMDevice *    device,

                                   GCancellable *cancellable,

                                   guint64 *     version_id,

                                   GError **     error)

{

    nm_auto_unref_gmainloop GMainLoop *main_loop = g_main_loop_new(NULL, FALSE);

    DeviceGetAppliedConnectionData     data      = {

        .main_loop = main_loop,

    };

    nm_device_get_applied_connection_async(device,

                                           0,

                                           cancellable,

                                           _nmcs_device_get_applied_connection_cb,

                                           &data);

    g_main_loop_run(main_loop);

    if (data.error)

        g_propagate_error(error, data.error);

    NM_SET_OUT(version_id, data.version_id);

    return data.connection;

}

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

typedef struct {

    GMainLoop *main_loop;

    GError *   error;

} DeviceReapplyData;

static void

_nmcs_device_reapply_cb(GObject *source, GAsyncResult *result, gpointer user_data)

{

    DeviceReapplyData *data = user_data;

    nm_device_reapply_finish(NM_DEVICE(source), result, &data->error);

    g_main_loop_quit(data->main_loop);

}

gboolean

nmcs_device_reapply(NMDevice *    device,

                    GCancellable *sigterm_cancellable,

                    NMConnection *connection,

                    guint64       version_id,

                    gboolean *    out_version_id_changed,

                    GError **     error)

{

    nm_auto_unref_gmainloop GMainLoop *main_loop = g_main_loop_new(NULL, FALSE);

    DeviceReapplyData                  data      = {

        .main_loop = main_loop,

    };

    nm_device_reapply_async(device,

                            connection,

                            version_id,

                            0,

                            sigterm_cancellable,

                            _nmcs_device_reapply_cb,

                            &data);

    g_main_loop_run(main_loop);

    if (data.error) {

        NM_SET_OUT(

            out_version_id_changed,

            g_error_matches(data.error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_VERSION_ID_MISMATCH));

        g_propagate_error(error, data.error);

        return FALSE;

    }

    NM_SET_OUT(out_version_id_changed, FALSE);

    return TRUE;

}