/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 * Copyright (C) 2010 Lennart Poettering
 * Copyright (C) 2010 - 2018 Red Hat, Inc.
 */

#include "libnm-client-aux-extern/nm-default-client.h"

#include "utils.h"

#include <stdio.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/auxv.h>
#include <sys/prctl.h>

#include "libnmc-base/nm-client-utils.h"
#include "libnmc-setting/nm-meta-setting-access.h"

#include "common.h"
#include "nmcli.h"
#include "settings.h"

#define ML_HEADER_WIDTH 79
#define ML_VALUE_INDENT 40

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

static const char *
_meta_type_nmc_generic_info_get_name(const NMMetaAbstractInfo *abstract_info, gboolean for_header)
{
    const NmcMetaGenericInfo *info = (const NmcMetaGenericInfo *) abstract_info;

    if (for_header)
        return info->name_header ?: info->name;
    return info->name;
}

static const NMMetaAbstractInfo *const *
_meta_type_nmc_generic_info_get_nested(const NMMetaAbstractInfo *abstract_info,
                                       guint                    *out_len,
                                       gpointer                 *out_to_free)
{
    const NmcMetaGenericInfo *info;

    info = (const NmcMetaGenericInfo *) abstract_info;

    NM_SET_OUT(out_len, NM_PTRARRAY_LEN(info->nested));
    return (const NMMetaAbstractInfo *const *) info->nested;
}

static gconstpointer
_meta_type_nmc_generic_info_get_fcn(const NMMetaAbstractInfo  *abstract_info,
                                    const NMMetaEnvironment   *environment,
                                    gpointer                   environment_user_data,
                                    gpointer                   target,
                                    gpointer                   target_data,
                                    NMMetaAccessorGetType      get_type,
                                    NMMetaAccessorGetFlags     get_flags,
                                    NMMetaAccessorGetOutFlags *out_flags,
                                    gboolean                  *out_is_default,
                                    gpointer                  *out_to_free)
{
    const NmcMetaGenericInfo *info = (const NmcMetaGenericInfo *) abstract_info;

    nm_assert(!out_to_free || !*out_to_free);
    nm_assert(out_flags && !*out_flags);

    if (!NM_IN_SET(get_type,
                   NM_META_ACCESSOR_GET_TYPE_PARSABLE,
                   NM_META_ACCESSOR_GET_TYPE_PRETTY,
                   NM_META_ACCESSOR_GET_TYPE_COLOR))
        g_return_val_if_reached(NULL);

    /* omitting the out_to_free value is only allowed for COLOR. */
    nm_assert(out_to_free || NM_IN_SET(get_type, NM_META_ACCESSOR_GET_TYPE_COLOR));

    if (info->get_fcn) {
        return info->get_fcn(environment,
                             environment_user_data,
                             info,
                             target,
                             target_data,
                             get_type,
                             get_flags,
                             out_flags,
                             out_is_default,
                             out_to_free);
    }

    if (info->nested) {
        NMC_HANDLE_COLOR(NM_META_COLOR_NONE);
        return info->name;
    }

    g_return_val_if_reached(NULL);
}

const NMMetaType nmc_meta_type_generic_info = {
    .type_name  = "nmc-generic-info",
    .get_name   = _meta_type_nmc_generic_info_get_name,
    .get_nested = _meta_type_nmc_generic_info_get_nested,
    .get_fcn    = _meta_type_nmc_generic_info_get_fcn,
};

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

static const char *
colorize_string(const NmcConfig *nmc_config, NMMetaColor color, const char *str, char **out_to_free)
{
    const char *out = str;

    if (nmc_config && nmc_config->use_colors) {
        *out_to_free = nmc_colorize(nmc_config, color, "%s", str);
        out          = *out_to_free;
    }

    return out;
}

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

static gboolean
parse_global_arg(NmCli *nmc, const char *arg)
{
    if (nmc_arg_is_option(arg, "ask"))
        nmc->ask = TRUE;
    else if (nmc_arg_is_option(arg, "show-secrets"))
        nmc->nmc_config_mutable.show_secrets = TRUE;
    else
        return FALSE;

    return TRUE;
}
/**
 * next_arg:
 * @nmc: NmCli data
 * @*argc: pointer to left number of arguments to parse
 * @***argv: pointer to const char *array of arguments still to parse
 * @...: a %NULL terminated list of cmd options to match (e.g., "--active")
 *
 * Takes care of autocompleting options when needed and performs
 * match against passed options while moving forward the pointer
 * to the remaining arguments.
 *
 * Returns: the number of the matched option  if a match is found against
 * one of the custom options passed; 0 if no custom option matched and still
 * some args need to be processed or autocompletion has been performed;
 * -1 otherwise (no more args).
 */
int
next_arg(NmCli *nmc, int *argc, const char *const **argv, ...)
{
    va_list     args;
    const char *cmd_option;

    g_return_val_if_fail(*argc >= 0, -1);

    do {
        int cmd_option_pos = 1;

        if (*argc > 0) {
            (*argc)--;
            (*argv)++;
        }
        if (*argc == 0)
            return -1;

        va_start(args, argv);

        if (nmc && nmc->complete && *argc == 1) {
            while ((cmd_option = va_arg(args, const char *)))
                nmc_complete_strings(**argv, cmd_option);

            if (***argv == '-')
                nmc_complete_strings(**argv, "--ask", "--show-secrets");

            va_end(args);
            return 0;
        }

        /* Check command dependent options first */
        while ((cmd_option = va_arg(args, const char *))) {
            if (cmd_option[0] == '-' && cmd_option[1] == '-') {
                /* Match as an option (leading "--" stripped) */
                if (nmc_arg_is_option(**argv, cmd_option + 2)) {
                    va_end(args);
                    return cmd_option_pos;
                }
            } else {
                /* Match literally. */
                if (strcmp(**argv, cmd_option) == 0) {
                    va_end(args);
                    return cmd_option_pos;
                }
            }
            cmd_option_pos++;
        }

        va_end(args);

    } while (nmc && parse_global_arg(nmc, **argv));

    return 0;
}

gboolean
nmc_arg_is_help(const char *arg)
{
    if (!arg)
        return FALSE;
    if (matches(arg, "help") || (g_str_has_prefix(arg, "-") && matches(arg + 1, "help"))
        || (g_str_has_prefix(arg, "--") && matches(arg + 2, "help"))) {
        return TRUE;
    }
    return FALSE;
}

gboolean
nmc_arg_is_option(const char *str, const char *opt_name)
{
    const char *p;

    if (!str || !*str)
        return FALSE;

    if (str[0] != '-')
        return FALSE;

    p = (str[1] == '-') ? str + 2 : str + 1;

    return (*p ? matches(p, opt_name) : FALSE);
}

/*
 * Helper function to parse command-line arguments.
 * arg_arr: description of arguments to look for
 * last:    whether these are last expected arguments
 * argc:    command-line argument array size
 * argv:    command-line argument array
 * error:   error set on a failure (when FALSE is returned)
 * Returns: TRUE on success, FALSE on an error and sets 'error'
 */
gboolean
nmc_parse_args(nmc_arg_t          *arg_arr,
               gboolean            last,
               int                *argc,
               const char *const **argv,
               GError            **error)
{
    nmc_arg_t *p;
    gboolean   found;
    gboolean   have_mandatory;

    g_return_val_if_fail(arg_arr != NULL, FALSE);
    g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

    while (*argc > 0) {
        found = FALSE;

        for (p = arg_arr; p->name; p++) {
            if (strcmp(**argv, p->name) == 0) {
                if (p->found) {
                    /* Don't allow repeated arguments, because the argument of the same
                     * name could be used later on the line for another purpose. Assume
                     * that's the case and return.
                     */
                    return TRUE;
                }

                if (p->has_value) {
                    (*argc)--;
                    (*argv)++;
                    if (!*argc) {
                        g_set_error(error,
                                    NMCLI_ERROR,
                                    NMC_RESULT_ERROR_USER_INPUT,
                                    _("Error: value for '%s' argument is required."),
                                    *(*argv - 1));
                        return FALSE;
                    }
                    *(p->value) = **argv;
                }
                p->found = TRUE;
                found    = TRUE;
                break;
            }
        }

        if (!found) {
            have_mandatory = TRUE;
            for (p = arg_arr; p->name; p++) {
                if (p->mandatory && !p->found) {
                    have_mandatory = FALSE;
                    break;
                }
            }

            if (have_mandatory && !last)
                return TRUE;

            if (p->name)
                g_set_error(error,
                            NMCLI_ERROR,
                            NMC_RESULT_ERROR_USER_INPUT,
                            _("Error: Argument '%s' was expected, but '%s' provided."),
                            p->name,
                            **argv);
            else
                g_set_error(error,
                            NMCLI_ERROR,
                            NMC_RESULT_ERROR_USER_INPUT,
                            _("Error: Unexpected argument '%s'"),
                            **argv);
            return FALSE;
        }

        next_arg(NULL, argc, argv, NULL);
    }

    return TRUE;
}

/*
 *  Convert SSID to a hex string representation.
 *  Caller has to free the returned string using g_free()
 */
char *
ssid_to_hex(const char *str, gsize len)
{
    if (len == 0)
        return NULL;

    return nm_utils_bin2hexstr_full(str, len, '\0', TRUE, NULL);
}

/*
 * Erase terminal line using ANSI escape sequences.
 * It prints <ESC>[2K sequence to erase the line and then \r to return back
 * to the beginning of the line.
 *
 * http://www.termsys.demon.co.uk/vtansi.htm
 */
void
nmc_terminal_erase_line(void)
{
    /* We intentionally use printf(), not nmc_print() here, to ensure that
     * GLib doesn't mistakenly try to convert the string.
     */
    printf("\33[2K\r");
    fflush(stdout);
}

/*
 * Print animated progress for an operation.
 * Repeated calls of the function will show rotating slash in terminal followed
 * by the string passed in 'str' argument.
 */
void
nmc_terminal_show_progress(const char *str)
{
    static int idx        = 0;
    const char slashes[4] = {'|', '/', '-', '\\'};

    nmc_terminal_erase_line();
    nmc_print("%c %s", slashes[idx++], str ?: "");
    fflush(stdout);
    if (idx == 4)
        idx = 0;
}

char *
nmc_colorize(const NmcConfig *nmc_config, NMMetaColor color, const char *fmt, ...)
{
    va_list       args;
    gs_free char *str      = NULL;
    const char   *ansi_seq = NULL;

    va_start(args, fmt);
    str = g_strdup_vprintf(fmt, args);
    va_end(args);

    if (nmc_config->use_colors)
        ansi_seq = nmc_config->palette.ansi_seq[color];

    if (!ansi_seq)
        return g_steal_pointer(&str);

    return g_strdup_printf("\33[%sm%s\33[0m", ansi_seq, str);
}

/*
 * Count characters belonging to terminal color escape sequences.
 * @start points to beginning of the string, @end points to the end,
 * or NULL if the string is nul-terminated.
 */
static int
nmc_count_color_escape_chars(const char *start, const char *end)
{
    int      num    = 0;
    gboolean inside = FALSE;

    if (end == NULL)
        end = start + strlen(start);

    while (start < end) {
        if (*start == '\33' && *(start + 1) == '[')
            inside = TRUE;
        if (inside)
            num++;
        if (*start == 'm')
            inside = FALSE;
        start++;
    }
    return num;
}

/* Filter out possible ANSI color escape sequences */
/* It directly modifies the passed string @str. */
void
nmc_filter_out_colors_inplace(char *str)
{
    const char *p1;
    char       *p2;
    gboolean    copy_char = TRUE;

    if (!str)
        return;

    p1 = p2 = str;
    while (*p1) {
        if (*p1 == '\33' && *(p1 + 1) == '[')
            copy_char = FALSE;
        if (copy_char)
            *p2++ = *p1;
        if (!copy_char && *p1 == 'm')
            copy_char = TRUE;
        p1++;
    }
    *p2 = '\0';
}

/* Filter out possible ANSI color escape sequences */
char *
nmc_filter_out_colors(const char *str)
{
    char *filtered;

    if (!str)
        return NULL;

    filtered = g_strdup(str);
    nmc_filter_out_colors_inplace(filtered);
    return filtered;
}

/*
 * Ask user for input and return the string.
 * The caller is responsible for freeing the returned string.
 */
char *
nmc_get_user_input(const char *ask_str)
{
    char   *line    = NULL;
    size_t  line_ln = 0;
    ssize_t num;

    nmc_print("%s", ask_str);
    num = getline(&line, &line_ln, stdin);

    /* Remove newline from the string */
    if (num < 1 || (num == 1 && line[0] == '\n')) {
        g_free(line);
        line = NULL;
    } else {
        if (line[num - 1] == '\n')
            line[num - 1] = '\0';
    }

    return line;
}

/*
 * Split string in 'line' according to 'delim' to (argument) array.
 */
int
nmc_string_to_arg_array(const char *line,
                        const char *delim,
                        gboolean    unquote,
                        char     ***argv,
                        int        *argc)
{
    gs_free const char **arr0 = NULL;
    char               **arr;

    arr0 = nm_strsplit_set(line ?: "", delim ?: " \t");
    if (!arr0)
        arr = nm_strv_empty_new();
    else
        arr = g_strdupv((char **) arr0);

    if (unquote) {
        int         i = 0;
        char       *s;
        size_t      l;
        const char *quotes = "\"'";

        while (arr[i]) {
            s = arr[i];
            l = strlen(s);
            if (l >= 2) {
                if (strchr(quotes, s[0]) && s[l - 1] == s[0]) {
                    memmove(s, s + 1, l - 2);
                    s[l - 2] = '\0';
                }
            }
            i++;
        }
    }

    *argv = arr;
    *argc = g_strv_length(arr);
    return 0;
}

/*
 * Convert string array (char **) to description string in the form of:
 * "[string1, string2, ]"
 *
 * Returns: a newly allocated string. Caller must free it with g_free().
 */
char *
nmc_util_strv_for_display(const char *const *strv, gboolean brackets)
{
    GString *result;
    guint    i = 0;

    result = g_string_sized_new(150);
    if (brackets)
        g_string_append_c(result, '[');
    while (strv && strv[i]) {
        if (result->len > 1)
            g_string_append(result, ", ");
        g_string_append(result, strv[i]);
        i++;
    }
    if (brackets)
        g_string_append_c(result, ']');

    return g_string_free(result, FALSE);
}

/*
 * Find out how many columns an UTF-8 string occupies on the screen.
 */
int
nmc_string_screen_width(const char *start, const char *end)
{
    int         width = 0;
    const char *p     = start;

    if (end == NULL)
        end = start + strlen(start);

    while (p < end) {
        width += g_unichar_iswide(g_utf8_get_char(p))        ? 2
                 : g_unichar_iszerowidth(g_utf8_get_char(p)) ? 0
                                                             : 1;
        p = g_utf8_next_char(p);
    }

    /* Subtract color escape sequences as they don't occupy space. */
    return width - nmc_count_color_escape_chars(start, NULL);
}

void
set_val_str(NmcOutputField fields_array[], guint32 idx, char *value)
{
    fields_array[idx].value          = value;
    fields_array[idx].value_is_array = FALSE;
    fields_array[idx].free_value     = TRUE;
}

void
set_val_strc(NmcOutputField fields_array[], guint32 idx, const char *value)
{
    fields_array[idx].value          = (char *) value;
    fields_array[idx].value_is_array = FALSE;
    fields_array[idx].free_value     = FALSE;
}

void
set_val_arr(NmcOutputField fields_array[], guint32 idx, char **value)
{
    fields_array[idx].value          = value;
    fields_array[idx].value_is_array = TRUE;
    fields_array[idx].free_value     = TRUE;
}

void
set_val_arrc(NmcOutputField fields_array[], guint32 idx, const char **value)
{
    fields_array[idx].value          = (char **) value;
    fields_array[idx].value_is_array = TRUE;
    fields_array[idx].free_value     = FALSE;
}

void
set_val_color_all(NmcOutputField fields_array[], NMMetaColor color)
{
    int i;

    for (i = 0; fields_array[i].info; i++) {
        fields_array[i].color = color;
    }
}

/*
 * Free 'value' members in array of NmcOutputField
 */
void
nmc_free_output_field_values(NmcOutputField fields_array[])
{
    NmcOutputField *iter = fields_array;

    while (iter && iter->info) {
        if (iter->free_value) {
            if (iter->value_is_array)
                g_strfreev((char **) iter->value);
            else
                g_free((char *) iter->value);
            iter->value = NULL;
        }
        iter++;
    }
}

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

#define PRINT_DATA_COL_PARENT_NIL (G_MAXUINT)

typedef struct _PrintDataCol {
    union {
        const struct _PrintDataCol *parent_col;

        /* while constructing the list of columns in _output_selection_append(), we keep track
         * of the parent by index. The reason is, that at that point our columns are still
         * tracked in a GArray which is growing (hence, the pointers are changing).
         * Later, _output_selection_complete() converts the index into the actual pointer.
         */
        guint _parent_idx;
    };
    const NMMetaSelectionItem *selection_item;
    guint                      self_idx;
    bool                       is_leaf;
} PrintDataCol;

static gboolean
_output_selection_append(GArray                    *cols,
                         guint                      parent_idx,
                         const NMMetaSelectionItem *selection_item,
                         GPtrArray                 *gfree_keeper,
                         GError                   **error)
{
    gs_free gpointer                 nested_to_free = NULL;
    guint                            col_idx;
    guint                            i;
    const NMMetaAbstractInfo *const *nested;
    NMMetaSelectionResultList       *selection;

    col_idx = cols->len;

    {
        PrintDataCol col = {
            .selection_item = selection_item,
            ._parent_idx    = parent_idx,
            .self_idx       = col_idx,
            .is_leaf        = TRUE,
        };
        g_array_append_val(cols, col);
    }

    nested = nm_meta_abstract_info_get_nested(selection_item->info, NULL, &nested_to_free);

    if (selection_item->sub_selection) {
        if (!nested) {
            gs_free char *allowed_fields = NULL;

            if (parent_idx != PRINT_DATA_COL_PARENT_NIL) {
                const NMMetaSelectionItem *si;

                si = nm_g_array_index(cols, PrintDataCol, parent_idx).selection_item;
                allowed_fields =
                    nm_meta_abstract_info_get_nested_names_str(si->info, si->self_selection);
            }
            if (!allowed_fields) {
                g_set_error(error,
                            NMCLI_ERROR,
                            1,
                            _("invalid field '%s%s%s'; no such field"),
                            selection_item->self_selection ?: "",
                            selection_item->self_selection ? "." : "",
                            selection_item->sub_selection);
            } else {
                g_set_error(error,
                            NMCLI_ERROR,
                            1,
                            _("invalid field '%s%s%s'; allowed fields: [%s]"),
                            selection_item->self_selection ?: "",
                            selection_item->self_selection ? "." : "",
                            selection_item->sub_selection,
                            allowed_fields);
            }
            return FALSE;
        }

        selection = nm_meta_selection_create_parse_one(nested,
                                                       selection_item->self_selection,
                                                       selection_item->sub_selection,
                                                       FALSE,
                                                       error);
        if (!selection)
            return FALSE;
        nm_assert(selection->num == 1);
    } else if (nested) {
        selection = nm_meta_selection_create_all(nested);
        nm_assert(selection && selection->num > 0);
    } else
        selection = NULL;

    if (selection) {
        g_ptr_array_add(gfree_keeper, selection);

        for (i = 0; i < selection->num; i++) {
            if (!_output_selection_append(cols, col_idx, &selection->items[i], gfree_keeper, error))
                return FALSE;
        }

        if (!NM_IN_SET(selection_item->info->meta_type,
                       &nm_meta_type_setting_info_editor,
                       &nmc_meta_type_generic_info))
            nm_g_array_index(cols, PrintDataCol, col_idx).is_leaf = FALSE;
    }

    return TRUE;
}

static void
_output_selection_complete(GArray *cols)
{
    guint i;

    nm_assert(cols);
    nm_assert(g_array_get_element_size(cols) == sizeof(PrintDataCol));

    for (i = 0; i < cols->len; i++) {
        PrintDataCol *col = &nm_g_array_index(cols, PrintDataCol, i);

        if (col->_parent_idx == PRINT_DATA_COL_PARENT_NIL)
            col->parent_col = NULL;
        else {
            nm_assert(col->_parent_idx < i);
            col->parent_col = &nm_g_array_index(cols, PrintDataCol, col->_parent_idx);
        }
    }
}

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

/**
 * _output_selection_parse:
 * @fields: a %NULL terminated array of meta-data fields
 * @fields_str: a comma separated selector for fields. Nested fields
 *   can be specified using '.' notation.
 * @out_cols: (transfer full): the result, parsed as an GArray of PrintDataCol items.
 *   The order of the items is as specified by @fields_str. Meta data
 *   items that contain nested elements are unpacked (note the is_leaf
 *   and parent properties of PrintDataCol).
 * @out_gfree_keeper: (transfer full): an output GPtrArray that owns
 *   strings to which @out_cols points to. The lifetime of @out_cols
 *   and @out_gfree_keeper should correspond.
 * @error:
 *
 * Returns: %TRUE on success.
 */
static gboolean
_output_selection_parse(const NMMetaAbstractInfo *const *fields,
                        const char                      *fields_str,
                        PrintDataCol                   **out_cols_data,
                        guint                           *out_cols_len,
                        GPtrArray                      **out_gfree_keeper,
                        GError                         **error)
{
    NMMetaSelectionResultList   *selection;
    gs_unref_ptrarray GPtrArray *gfree_keeper = NULL;
    gs_unref_array GArray       *cols         = NULL;
    guint                        i;

    selection = nm_meta_selection_create_parse_list(fields, fields_str, FALSE, error);
    if (!selection)
        return FALSE;

    if (!selection->num) {
        g_set_error(error, NMCLI_ERROR, 1, _("failure to select field"));
        g_free(selection);
        return FALSE;
    }

    gfree_keeper = g_ptr_array_new_with_free_func(g_free);
    g_ptr_array_add(gfree_keeper, selection);

    cols = g_array_new(FALSE, TRUE, sizeof(PrintDataCol));

    for (i = 0; i < selection->num; i++) {
        if (!_output_selection_append(cols,
                                      PRINT_DATA_COL_PARENT_NIL,
                                      &selection->items[i],
                                      gfree_keeper,
                                      error))
            return FALSE;
    }

    _output_selection_complete(cols);

    *out_cols_len     = cols->len;
    *out_cols_data    = (PrintDataCol *) ((gpointer) g_array_free(g_steal_pointer(&cols), FALSE));
    *out_gfree_keeper = g_steal_pointer(&gfree_keeper);
    return TRUE;
}

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

/**
 * parse_output_fields:
 * @field_str: comma-separated field names to parse
 * @fields_array: array of allowed fields
 * @parse_groups: whether the fields can contain group prefix (e.g. general.driver)
 * @group_fields: (out) (optional) (nullable): array of field names for particular groups
 * @error: location to store error, or %NULL
 *
 * Parses comma separated fields in @fields_str according to @fields_array.
 * When @parse_groups is %TRUE, fields can be in the form 'group.field'. Then
 * @group_fields will be filled with the required field for particular group.
 * @group_fields array corresponds to the returned array.
 * Examples:
 *   @field_str:     "type,name,uuid" | "ip4,general.device" | "ip4.address,ip6"
 *   returned array:   2    0    1    |   7         0        |     7         9
 *   @group_fields:   NULL NULL NULL  |  NULL    "device"    | "address"    NULL
 *
 * Returns: #GArray with indices representing fields in @fields_array.
 *   Caller is responsible for freeing the array.
 */
GArray *
parse_output_fields(const char                      *fields_str,
                    const NMMetaAbstractInfo *const *fields_array,
                    gboolean                         parse_groups,
                    GPtrArray                      **out_group_fields,
                    GError                         **error)
{
    gs_free NMMetaSelectionResultList *selection = NULL;
    GArray                            *array;
    GPtrArray                         *group_fields = NULL;
    guint                              i;

    g_return_val_if_fail(!error || !*error, NULL);
    g_return_val_if_fail(!out_group_fields || !*out_group_fields, NULL);

    selection = nm_meta_selection_create_parse_list(fields_array, fields_str, TRUE, error);
    if (!selection)
        return NULL;

    array = g_array_sized_new(FALSE, FALSE, sizeof(int), selection->num);
    if (parse_groups && out_group_fields)
        group_fields = g_ptr_array_new_full(selection->num, g_free);

    for (i = 0; i < selection->num; i++) {
        int idx = selection->items[i].idx;

        g_array_append_val(array, idx);
        if (group_fields)
            g_ptr_array_add(group_fields, g_strdup(selection->items[i].sub_selection));
    }

    if (group_fields)
        *out_group_fields = group_fields;
    return array;
}

NmcOutputField *
nmc_dup_fields_array(const NMMetaAbstractInfo *const *fields, NmcOfFlags flags)
{
    NmcOutputField *row;
    gsize           l;

    for (l = 0; fields[l]; l++) {}

    row = g_new0(NmcOutputField, l + 1);
    for (l = 0; fields[l]; l++)
        row[l].info = fields[l];
    row[0].flags = flags;
    return row;
}

void
nmc_empty_output_fields(NmcOutputData *output_data)
{
    guint i;

    /* Free values in field structure */
    for (i = 0; i < output_data->output_data->len; i++) {
        NmcOutputField *fld_arr = g_ptr_array_index(output_data->output_data, i);
        nmc_free_output_field_values(fld_arr);
    }

    /* Empty output_data array */
    if (output_data->output_data->len > 0)
        g_ptr_array_remove_range(output_data->output_data, 0, output_data->output_data->len);

    g_ptr_array_unref(output_data->output_data);
}

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

typedef struct {
    guint               col_idx;
    const PrintDataCol *col;
    const char         *title;
    bool                title_to_free : 1;

    /* whether the column should be printed. If not %TRUE,
     * the column will be skipped. */
    bool to_print : 1;

    int width;
} PrintDataHeaderCell;

typedef enum {
    PRINT_DATA_CELL_FORMAT_TYPE_PLAIN = 0,
    PRINT_DATA_CELL_FORMAT_TYPE_STRV,
} PrintDataCellFormatType;

typedef struct {
    guint                      row_idx;
    const PrintDataHeaderCell *header_cell;
    NMMetaColor                color;
    union {
        const char        *plain;
        const char *const *strv;
    } text;
    PrintDataCellFormatType text_format : 3;
    bool                    text_to_free : 1;
} PrintDataCell;

static void
_print_data_header_cell_clear(gpointer cell_p)
{
    PrintDataHeaderCell *cell = cell_p;

    if (cell->title_to_free) {
        g_free((char *) cell->title);
        cell->title_to_free = FALSE;
    }
    cell->title = NULL;
}

static void
_print_data_cell_clear_text(PrintDataCell *cell)
{
    switch (cell->text_format) {
    case PRINT_DATA_CELL_FORMAT_TYPE_PLAIN:
        if (cell->text_to_free)
            g_free((char *) cell->text.plain);
        cell->text.plain = NULL;
        break;
    case PRINT_DATA_CELL_FORMAT_TYPE_STRV:
        if (cell->text_to_free)
            g_strfreev((char **) cell->text.strv);
        cell->text.strv = NULL;
        break;
    };
    cell->text_format  = PRINT_DATA_CELL_FORMAT_TYPE_PLAIN;
    cell->text_to_free = FALSE;
}

static void
_print_data_cell_clear(gpointer cell_p)
{
    PrintDataCell *cell = cell_p;

    _print_data_cell_clear_text(cell);
}

static void
_print_fill(const NmcConfig    *nmc_config,
            gpointer const     *targets,
            gpointer            targets_data,
            const PrintDataCol *cols,
            guint               cols_len,
            GArray            **out_header_row,
            GArray            **out_cells)
{
    GArray                *cells;
    GArray                *header_row;
    guint                  i_row, i_col;
    guint                  targets_len;
    NMMetaAccessorGetType  text_get_type;
    NMMetaAccessorGetFlags text_get_flags;

    header_row = g_array_sized_new(FALSE, TRUE, sizeof(PrintDataHeaderCell), cols_len);
    g_array_set_clear_func(header_row, _print_data_header_cell_clear);

    for (i_col = 0; i_col < cols_len; i_col++) {
        const PrintDataCol       *col;
        PrintDataHeaderCell      *header_cell;
        guint                     col_idx;
        const NMMetaAbstractInfo *info;
        const char               *setting_name;
        gboolean                  is_prop;

        col = &cols[i_col];
        if (!col->is_leaf)
            continue;

        info = col->selection_item->info;

        col_idx = header_row->len;
        g_array_set_size(header_row, col_idx + 1);

        header_cell = &nm_g_array_index(header_row, PrintDataHeaderCell, col_idx);

        header_cell->col_idx = col_idx;
        header_cell->col     = col;

        /* by default, the entire column is skipped. That is the case,
         * unless we have a cell (below) which opts-in to be printed. */
        header_cell->to_print = FALSE;

        header_cell->title = nm_meta_abstract_info_get_name(info, TRUE);

        is_prop =
            col->parent_col
            && NM_IN_SET(info->meta_type, &nm_meta_type_property_info, &nmc_meta_type_generic_info);

        if (is_prop) {
            /* Some properties has different name for the user than internally in
             * libnm and D-Bus. Make the conversion from libnm names to user names.
             */
            setting_name =
                nm_meta_abstract_info_get_name(col->parent_col->selection_item->info, FALSE);
            header_cell->title =
                nmc_setting_propname_libnm_to_user(setting_name, header_cell->title);
        }

        if (nmc_config->multiline_output && is_prop) {
            header_cell->title         = g_strdup_printf("%s.%s", setting_name, header_cell->title);
            header_cell->title_to_free = TRUE;
        }
    }

    targets_len = NM_PTRARRAY_LEN(targets);

    cells = g_array_sized_new(FALSE, TRUE, sizeof(PrintDataCell), targets_len * header_row->len);
    g_array_set_clear_func(cells, _print_data_cell_clear);
    g_array_set_size(cells, targets_len * header_row->len);

    text_get_type  = nmc_print_output_to_accessor_get_type(nmc_config->print_output);
    text_get_flags = NM_META_ACCESSOR_GET_FLAGS_ACCEPT_STRV;
    if (nmc_config->show_secrets)
        text_get_flags |= NM_META_ACCESSOR_GET_FLAGS_SHOW_SECRETS;

    for (i_row = 0; i_row < targets_len; i_row++) {
        gpointer       target = targets[i_row];
        PrintDataCell *cells_line =
            &nm_g_array_index(cells, PrintDataCell, i_row * header_row->len);

        for (i_col = 0; i_col < header_row->len; i_col++) {
            char                     *to_free = NULL;
            PrintDataCell            *cell    = &cells_line[i_col];
            PrintDataHeaderCell      *header_cell;
            const NMMetaAbstractInfo *info;
            NMMetaAccessorGetOutFlags text_out_flags, color_out_flags;
            gconstpointer             value;
            gboolean                  is_default;

            header_cell = &nm_g_array_index(header_row, PrintDataHeaderCell, i_col);
            info        = header_cell->col->selection_item->info;

            cell->row_idx     = i_row;
            cell->header_cell = header_cell;

            value = nm_meta_abstract_info_get(info,
                                              nmc_meta_environment,
                                              (gpointer) nmc_meta_environment_arg,
                                              target,
                                              targets_data,
                                              text_get_type,
                                              text_get_flags,
                                              &text_out_flags,
                                              &is_default,
                                              (gpointer *) &to_free);

            nm_assert(!to_free || value == to_free);

            if ((is_default && nmc_config->overview)
                || NM_FLAGS_HAS(text_out_flags, NM_META_ACCESSOR_GET_OUT_FLAGS_HIDE)) {
                /* don't mark the entry for display. This is to shorten the output in case
                 * the property is the default value. But we only do that, if the user
                 * opts in to this behavior (-overview), or of the property marks itself
                 * eligible to be hidden.
                 *
                 * In general, only new API shall mark itself eligible to be hidden.
                 * Long established properties cannot, because it would be a change
                 * in behavior. */
            } else
                header_cell->to_print = TRUE;

            if (NM_FLAGS_HAS(text_out_flags, NM_META_ACCESSOR_GET_OUT_FLAGS_STRV)) {
                if (nmc_config->multiline_output) {
                    cell->text_format  = PRINT_DATA_CELL_FORMAT_TYPE_STRV;
                    cell->text.strv    = value;
                    cell->text_to_free = !!to_free;
                } else {
                    if (value && ((const char *const *) value)[0]) {
                        cell->text.plain   = g_strjoinv(" | ", (char **) value);
                        cell->text_to_free = TRUE;
                    }
                    if (to_free)
                        g_strfreev(NM_CAST_ALIGN(char *, to_free));
                }
            } else {
                cell->text.plain   = value;
                cell->text_to_free = !!to_free;
            }

            cell->color =
                GPOINTER_TO_INT(nm_meta_abstract_info_get(info,
                                                          nmc_meta_environment,
                                                          (gpointer) nmc_meta_environment_arg,
                                                          target,
                                                          targets_data,
                                                          NM_META_ACCESSOR_GET_TYPE_COLOR,
                                                          NM_META_ACCESSOR_GET_FLAGS_NONE,
                                                          &color_out_flags,
                                                          NULL,
                                                          NULL));

            if (cell->text_format == PRINT_DATA_CELL_FORMAT_TYPE_PLAIN) {
                if (NM_IN_SET(nmc_config->print_output, NMC_PRINT_NORMAL, NMC_PRINT_PRETTY)
                    && (!cell->text.plain || !cell->text.plain[0])) {
                    _print_data_cell_clear_text(cell);
                    cell->text.plain = "--";
                } else if (!cell->text.plain)
                    cell->text.plain = "";
                nm_assert(cell->text_format == PRINT_DATA_CELL_FORMAT_TYPE_PLAIN);
            }
        }
    }

    for (i_col = 0; i_col < header_row->len; i_col++) {
        PrintDataHeaderCell *header_cell =
            &nm_g_array_index(header_row, PrintDataHeaderCell, i_col);

        header_cell->width = nmc_string_screen_width(header_cell->title, NULL);

        for (i_row = 0; i_row < targets_len; i_row++) {
            const PrintDataCell *cells_line =
                &nm_g_array_index(cells, PrintDataCell, i_row * header_row->len);
            const PrintDataCell *cell = &cells_line[i_col];
            const char *const   *i_strv;

            switch (cell->text_format) {
            case PRINT_DATA_CELL_FORMAT_TYPE_PLAIN:
                header_cell->width =
                    NM_MAX(header_cell->width, nmc_string_screen_width(cell->text.plain, NULL));
                break;
            case PRINT_DATA_CELL_FORMAT_TYPE_STRV:
                i_strv = cell->text.strv;
                if (i_strv) {
                    for (; *i_strv; i_strv++) {
                        header_cell->width =
                            NM_MAX(header_cell->width, nmc_string_screen_width(*i_strv, NULL));
                    }
                }
                break;
            }
        }

        header_cell->width += 1;
    }

    *out_header_row = header_row;
    *out_cells      = cells;
}

static gboolean
_print_skip_column(const NmcConfig *nmc_config, const PrintDataHeaderCell *header_cell)
{
    const NMMetaSelectionItem *selection_item;
    const NMMetaAbstractInfo  *info;

    selection_item = header_cell->col->selection_item;
    info           = selection_item->info;

    if (!header_cell->to_print)
        return TRUE;

    if (nmc_config->multiline_output) {
        if (info->meta_type == &nm_meta_type_setting_info_editor) {
            /* we skip the "name" entry for the setting in multiline output. */
            return TRUE;
        }
        if (info->meta_type == &nmc_meta_type_generic_info
            && ((const NmcMetaGenericInfo *) info)->nested) {
            /* skip the "name" entry for parent generic-infos */
            return TRUE;
        }
    } else {
        if (NM_IN_SET(info->meta_type,
                      &nm_meta_type_setting_info_editor,
                      &nmc_meta_type_generic_info)
            && selection_item->sub_selection) {
            /* in tabular form, we skip the "name" entry for sections that have sub-selections.
             * That is, for "ipv4.may-fail", but not for "ipv4". */
            return TRUE;
        }
    }
    return FALSE;
}

static void
_print_do(const NmcConfig           *nmc_config,
          const char                *header_name_no_l10n,
          guint                      col_len,
          guint                      row_len,
          const PrintDataHeaderCell *header_row,
          const PrintDataCell       *cells)
{
    int                           width1, width2;
    int                           table_width = 0;
    guint                         i_row, i_col;
    nm_auto_free_gstring GString *str = NULL;

    g_return_if_fail(col_len);

    /* Main header */
    if (nmc_config->print_output == NMC_PRINT_PRETTY && header_name_no_l10n) {
        gs_free char *line = NULL;
        int           header_width;
        const char   *header_name = _(header_name_no_l10n);

        header_width = nmc_string_screen_width(header_name, NULL) + 4;

        if (nmc_config->multiline_output) {
            table_width = NM_MAX(header_width, ML_HEADER_WIDTH);
            line        = g_strnfill(ML_HEADER_WIDTH, '=');
        } else { /* tabular */
            table_width = NM_MAX(table_width, header_width);
            line        = g_strnfill(table_width, '=');
        }

        width1 = strlen(header_name);
        width2 = nmc_string_screen_width(header_name, NULL);
        nmc_print("%s\n", line);
        nmc_print("%*s\n", (table_width + width2) / 2 + width1 - width2, header_name);
        nmc_print("%s\n", line);
    }

    str = !nmc_config->multiline_output ? g_string_sized_new(100) : NULL;

    /* print the header for the tabular form */
    if (NM_IN_SET(nmc_config->print_output, NMC_PRINT_NORMAL, NMC_PRINT_PRETTY)
        && !nmc_config->multiline_output) {
        for (i_col = 0; i_col < col_len; i_col++) {
            const PrintDataHeaderCell *header_cell = &header_row[i_col];
            const char                *title;

            if (_print_skip_column(nmc_config, header_cell))
                continue;

            title = header_cell->title;

            width1 = strlen(title);
            width2 =
                nmc_string_screen_width(title, NULL); /* Width of the string (in screen columns) */
            g_string_append_printf(str,
                                   "%-*s",
                                   (int) (header_cell->width + width1 - width2),
                                   title);
            g_string_append_c(str, ' '); /* Column separator */
            table_width += header_cell->width + width1 - width2 + 1;
        }

        if (str->len)
            g_string_truncate(str, str->len - 1); /* Chop off last column separator */
        nmc_print("%s\n", str->str);
        g_string_truncate(str, 0);

        /* Print horizontal separator */
        if (nmc_config->print_output == NMC_PRINT_PRETTY) {
            gs_free char *line = NULL;

            nmc_print("%s\n", (line = g_strnfill(table_width, '-')));
        }
    }

    for (i_row = 0; i_row < row_len; i_row++) {
        const PrintDataCell *current_line = &cells[i_row * col_len];

        for (i_col = 0; i_col < col_len; i_col++) {
            const PrintDataCell *cell  = &current_line[i_col];
            const char *const   *lines = NULL;
            guint                i_lines, lines_len;

            if (_print_skip_column(nmc_config, cell->header_cell))
                continue;

            lines_len = 0;
            switch (cell->text_format) {
            case PRINT_DATA_CELL_FORMAT_TYPE_PLAIN:
                lines     = &cell->text.plain;
                lines_len = 1;
                break;
            case PRINT_DATA_CELL_FORMAT_TYPE_STRV:
                nm_assert(nmc_config->multiline_output);
                lines     = cell->text.strv;
                lines_len = NM_PTRARRAY_LEN(lines);
                break;
            }

            for (i_lines = 0; i_lines < lines_len; i_lines++) {
                gs_free char *text_to_free = NULL;
                const char   *text;

                text = colorize_string(nmc_config, cell->color, lines[i_lines], &text_to_free);
                if (nmc_config->multiline_output) {
                    gs_free char *prefix = NULL;

                    if (cell->text_format == PRINT_DATA_CELL_FORMAT_TYPE_STRV)
                        prefix = g_strdup_printf("%s[%u]:", cell->header_cell->title, i_lines + 1);
                    else
                        prefix = g_strdup_printf("%s:", cell->header_cell->title);
                    width1 = strlen(prefix);
                    width2 = nmc_string_screen_width(prefix, NULL);
                    nmc_print("%-*s%s\n",
                              (int) (nmc_config->print_output == NMC_PRINT_TERSE
                                         ? 0
                                         : ML_VALUE_INDENT + width1 - width2),
                              prefix,
                              text);
                } else {
                    nm_assert(str);
                    if (nmc_config->print_output == NMC_PRINT_TERSE) {
                        if (nmc_config->escape_values) {
                            const char *p = text;
                            while (*p) {
                                if (*p == ':' || *p == '\\')
                                    g_string_append_c(str, '\\'); /* Escaping by '\' */
                                g_string_append_c(str, *p);
                                p++;
                            }
                        } else
                            g_string_append_printf(str, "%s", text);
                        g_string_append_c(str, ':'); /* Column separator */
                    } else {
                        const PrintDataHeaderCell *header_cell = &header_row[i_col];

                        width1 = strlen(text);
                        width2 = nmc_string_screen_width(
                            text,
                            NULL); /* Width of the string (in screen columns) */
                        g_string_append_printf(str,
                                               "%-*s",
                                               (int) (header_cell->width + width1 - width2),
                                               text);
                        g_string_append_c(str, ' '); /* Column separator */
                        table_width += header_cell->width + width1 - width2 + 1;
                    }
                }
            }
        }

        if (!nmc_config->multiline_output) {
            if (str->len)
                g_string_truncate(str, str->len - 1); /* Chop off last column separator */
            nmc_print("%s\n", str->str);

            g_string_truncate(str, 0);
        }

        if (nmc_config->print_output == NMC_PRINT_PRETTY && nmc_config->multiline_output) {
            gs_free char *line = NULL;

            nmc_print("%s\n", (line = g_strnfill(ML_HEADER_WIDTH, '-')));
        }
    }
}

gboolean
nmc_print_table(const NmcConfig                 *nmc_config,
                gpointer const                  *targets,
                gpointer                         targets_data,
                const char                      *header_name_no_l10n,
                const NMMetaAbstractInfo *const *fields,
                const char                      *fields_str,
                GError                         **error)
{
    gs_unref_ptrarray GPtrArray *gfree_keeper = NULL;
    gs_free PrintDataCol        *cols_data    = NULL;
    guint                        cols_len;
    gs_unref_array GArray       *header_row = NULL;
    gs_unref_array GArray       *cells      = NULL;

    if (!_output_selection_parse(fields, fields_str, &cols_data, &cols_len, &gfree_keeper, error))
        return FALSE;

    _print_fill(nmc_config, targets, targets_data, cols_data, cols_len, &header_row, &cells);

    _print_do(nmc_config,
              header_name_no_l10n,
              header_row->len,
              cells->len / header_row->len,
              nm_g_array_first_p(header_row, PrintDataHeaderCell),
              nm_g_array_first_p(cells, PrintDataCell));

    return TRUE;
}

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

static void
pager_fallback(void)
{
    char buf[1024];
    int  rb;

    /* We are still in the child process (after fork() and before exec()).
     * We must only used functions listed in `man signal-safety`. */

    do {
        rb = read(STDIN_FILENO, buf, sizeof(buf));
        if (rb == -1) {
            if (errno == EINTR)
                continue;
            _exit(EXIT_FAILURE);
        }
        if (write(STDOUT_FILENO, buf, rb) == -1) {
            _exit(EXIT_FAILURE);
        }
    } while (rb > 0);

    _exit(EXIT_SUCCESS);
}

pid_t
nmc_terminal_spawn_pager(const NmcConfig *nmc_config)
{
    const char        *pager = getenv("PAGER");
    pid_t              pager_pid;
    pid_t              parent_pid;
    int                fd[2];
    int                errsv;
    gs_strfreev char **ev = NULL;

    if (nmc_config->in_editor || nmc_config->print_output == NMC_PRINT_TERSE
        || !nmc_config->use_colors || g_strcmp0(pager, "") == 0 || getauxval(AT_SECURE))
        return 0;

    if (pipe(fd) == -1) {
        errsv = errno;
        nmc_printerr(_("Failed to create pager pipe: %s\n"), nm_strerror_native(errsv));
        return 0;
    }

    parent_pid = getpid();

    ev = g_get_environ();
    ev = g_environ_setenv(ev, "LESS", "FRSXMK", TRUE);
    ev = g_environ_setenv(ev, "LESSCHARSET", "utf-8", TRUE);
    ev = g_environ_setenv(ev, "LESSSECURE", "1", FALSE);

    pager_pid = fork();
    if (pager_pid == -1) {
        errsv = errno;
        nmc_printerr(_("Failed to fork pager: %s\n"), nm_strerror_native(errsv));
        nm_close(fd[0]);
        nm_close(fd[1]);
        return 0;
    }

    /* In the child start the pager */
    if (pager_pid == 0) {
        dup2(fd[0], STDIN_FILENO);
        nm_close(fd[0]);
        nm_close(fd[1]);

        /* Make sure the pager goes away when the parent dies */
        if (prctl(PR_SET_PDEATHSIG, SIGTERM) < 0)
            _exit(EXIT_FAILURE);

        /* Check whether our parent died before we were able
         * to set the death signal */
        if (getppid() != parent_pid)
            _exit(EXIT_SUCCESS);

        if (pager) {
            execvpe(pager, (char **) NM_MAKE_STRV(pager), ev);
            execvpe("/bin/sh", (char **) NM_MAKE_STRV("sh", "-c", pager), ev);
        }

        /* Debian's alternatives command for pagers is
         * called 'pager'. Note that we do not call
         * sensible-pagers here, since that is just a
         * shell script that implements a logic that
         * is similar to this one anyway, but is
         * Debian-specific. */
        execvpe("pager", (char **) NM_MAKE_STRV("pager"), ev);

        execvpe("less", (char **) NM_MAKE_STRV("less"), ev);
        execvpe("more", (char **) NM_MAKE_STRV("more"), ev);

        pager_fallback();
        /* not reached */
    }

    /* Return in the parent */
    if (dup2(fd[1], STDOUT_FILENO) < 0) {
        errsv = errno;
        nmc_printerr(_("Failed to duplicate pager pipe: %s\n"), nm_strerror_native(errsv));
    }
    if (dup2(fd[1], STDERR_FILENO) < 0) {
        errsv = errno;
        nmc_printerr(_("Failed to duplicate pager pipe: %s\n"), nm_strerror_native(errsv));
    }

    nm_close(fd[0]);
    nm_close(fd[1]);
    return pager_pid;
}

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

static const char *
get_value_to_print(const NmcConfig      *nmc_config,
                   const NmcOutputField *field,
                   gboolean              field_name,
                   const char           *not_set_str,
                   char                **out_to_free)
{
    gboolean      is_array = field->value_is_array;
    const char   *value;
    const char   *out;
    gs_free char *free_value = NULL;

    nm_assert(out_to_free && !*out_to_free);

    if (field_name)
        value = nm_meta_abstract_info_get_name(field->info, FALSE);
    else {
        value = field->value ? (is_array ? (free_value = g_strjoinv(" | ", (char **) field->value))
                                : (*((const char *) field->value)) ? field->value
                                                                   : not_set_str)
                             : not_set_str;
    }

    /* colorize the value */
    out = colorize_string(nmc_config, field->color, value, out_to_free);

    if (out && out == free_value) {
        nm_assert(!*out_to_free);
        *out_to_free = g_steal_pointer(&free_value);
    }

    return out;
}

/*
 * Print both headers or values of 'field_values' array.
 * Entries to print and their order are specified via indices in
 * 'nmc->indices' array.
 * Various flags influencing the output of fields are set up in the first item
 * of 'field_values' array.
 */
void
print_required_fields(const NmcConfig      *nmc_config,
                      NmcPagerData         *pager_data,
                      NmcOfFlags            of_flags,
                      const GArray         *indices,
                      const char           *header_name,
                      int                   indent,
                      const NmcOutputField *field_values)
{
    nm_auto_free_gstring GString *str = NULL;
    int                           width1, width2;
    int                           table_width = 0;
    const char                   *not_set_str;
    int                           i;
    gboolean                      main_header_add  = of_flags & NMC_OF_FLAG_MAIN_HEADER_ADD;
    gboolean                      main_header_only = of_flags & NMC_OF_FLAG_MAIN_HEADER_ONLY;
    gboolean                      field_names      = of_flags & NMC_OF_FLAG_FIELD_NAMES;
    gboolean                      section_prefix   = of_flags & NMC_OF_FLAG_SECTION_PREFIX;

    nm_cli_spawn_pager(nmc_config, pager_data);

    /* --- Main header --- */
    if (nmc_config->print_output == NMC_PRINT_PRETTY && (main_header_add || main_header_only)) {
        gs_free char *line = NULL;
        int           header_width;

        header_width = nmc_string_screen_width(header_name, NULL) + 4;

        if (nmc_config->multiline_output) {
            table_width = NM_MAX(header_width, ML_HEADER_WIDTH);
            line        = g_strnfill(ML_HEADER_WIDTH, '=');
        } else { /* tabular */
            table_width = NM_MAX(table_width, header_width);
            line        = g_strnfill(table_width, '=');
        }

        width1 = strlen(header_name);
        width2 = nmc_string_screen_width(header_name, NULL);
        nmc_print("%s\n", line);
        nmc_print("%*s\n", (table_width + width2) / 2 + width1 - width2, header_name);
        nmc_print("%s\n", line);
    }

    if (main_header_only)
        return;

    /* No field headers are printed in terse mode nor for multiline output */
    if ((nmc_config->print_output == NMC_PRINT_TERSE || nmc_config->multiline_output)
        && field_names)
        return;

    /* Don't replace empty strings in terse mode */
    not_set_str = nmc_config->print_output == NMC_PRINT_TERSE ? "" : "--";

    if (nmc_config->multiline_output) {
        for (i = 0; i < indices->len; i++) {
            int      idx      = nm_g_array_index(indices, int, i);
            gboolean is_array = field_values[idx].value_is_array;

            /* section prefix can't be an array */
            g_return_if_fail(!is_array || !section_prefix || idx != 0);

            if (section_prefix && idx == 0) /* The first field is section prefix */
                continue;

            if (is_array) {
                gs_free char *val_to_free = NULL;
                const char  **p, *val, *print_val;
                int           j;

                /* value is a null-terminated string array */

                for (p = (const char **) field_values[idx].value, j = 1; p && *p; p++, j++) {
                    gs_free char *tmp = NULL;

                    val = *p ?: not_set_str;
                    print_val =
                        colorize_string(nmc_config, field_values[idx].color, val, &val_to_free);
                    tmp = g_strdup_printf(
                        "%s%s%s[%d]:",
                        section_prefix ? (const char *) field_values[0].value : "",
                        section_prefix ? "." : "",
                        nm_meta_abstract_info_get_name(field_values[idx].info, FALSE),
                        j);
                    width1 = strlen(tmp);
                    width2 = nmc_string_screen_width(tmp, NULL);
                    nmc_print("%-*s%s\n",
                              (int) (nmc_config->print_output == NMC_PRINT_TERSE
                                         ? 0
                                         : ML_VALUE_INDENT + width1 - width2),
                              tmp,
                              print_val);
                }
            } else {
                gs_free char *val_to_free = NULL;
                gs_free char *tmp         = NULL;
                const char   *hdr_name    = (const char *) field_values[0].value;
                const char   *val         = (const char *) field_values[idx].value;
                const char   *print_val;

                /* value is a string */

                val       = val && *val ? val : not_set_str;
                print_val = colorize_string(nmc_config, field_values[idx].color, val, &val_to_free);
                tmp =
                    g_strdup_printf("%s%s%s:",
                                    section_prefix ? hdr_name : "",
                                    section_prefix ? "." : "",
                                    nm_meta_abstract_info_get_name(field_values[idx].info, FALSE));
                width1 = strlen(tmp);
                width2 = nmc_string_screen_width(tmp, NULL);
                nmc_print("%-*s%s\n",
                          (int) (nmc_config->print_output == NMC_PRINT_TERSE
                                     ? 0
                                     : ML_VALUE_INDENT + width1 - width2),
                          tmp,
                          print_val);
            }
        }
        if (nmc_config->print_output == NMC_PRINT_PRETTY) {
            gs_free char *line = NULL;

            nmc_print("%s\n", (line = g_strnfill(ML_HEADER_WIDTH, '-')));
        }

        return;
    }

    /* --- Tabular mode: each line = one object --- */

    str = g_string_new(NULL);

    for (i = 0; i < indices->len; i++) {
        gs_free char *val_to_free = NULL;
        int           idx;
        const char   *value;

        idx = nm_g_array_index(indices, int, i);

        value = get_value_to_print(nmc_config,
                                   (NmcOutputField *) field_values + idx,
                                   field_names,
                                   not_set_str,
                                   &val_to_free);

        if (nmc_config->print_output == NMC_PRINT_TERSE) {
            if (nmc_config->escape_values) {
                const char *p = value;
                while (*p) {
                    if (*p == ':' || *p == '\\')
                        g_string_append_c(str, '\\'); /* Escaping by '\' */
                    g_string_append_c(str, *p);
                    p++;
                }
            } else
                g_string_append_printf(str, "%s", value);
            g_string_append_c(str, ':'); /* Column separator */
        } else {
            width1 = strlen(value);
            width2 =
                nmc_string_screen_width(value, NULL); /* Width of the string (in screen columns) */
            g_string_append_printf(str,
                                   "%-*s",
                                   field_values[idx].width + width1 - width2,
                                   strlen(value) > 0 ? value : not_set_str);
            g_string_append_c(str, ' '); /* Column separator */
            table_width += field_values[idx].width + width1 - width2 + 1;
        }
    }

    /* Print actual values */
    if (str->len > 0) {
        g_string_truncate(str, str->len - 1); /* Chop off last column separator */
        if (indent > 0) {
            gs_free char *indent_str = NULL;

            g_string_prepend(str, (indent_str = g_strnfill(indent, ' ')));
        }

        nmc_print("%s\n", str->str);

        /* Print horizontal separator */
        if (nmc_config->print_output == NMC_PRINT_PRETTY && field_names) {
            gs_free char *line = NULL;

            nmc_print("%s\n", (line = g_strnfill(table_width, '-')));
        }
    }
}

void
print_data_prepare_width(GPtrArray *output_data)
{
    int             i, j;
    size_t          len;
    NmcOutputField *row;
    int             num_fields = 0;

    if (!output_data || output_data->len < 1)
        return;

    /* How many fields? */
    row = g_ptr_array_index(output_data, 0);
    while (row->info) {
        num_fields++;
        row++;
    }

    /* Find out maximal string lengths */
    for (i = 0; i < num_fields; i++) {
        size_t max_width = 0;
        for (j = 0; j < output_data->len; j++) {
            gboolean      field_names;
            gs_free char *val_to_free = NULL;
            const char   *value;

            row         = g_ptr_array_index(output_data, j);
            field_names = row[0].flags & NMC_OF_FLAG_FIELD_NAMES;
            value       = get_value_to_print(NULL, row + i, field_names, "--", &val_to_free);
            len         = nmc_string_screen_width(value, NULL);
            max_width   = len > max_width ? len : max_width;
        }
        for (j = 0; j < output_data->len; j++) {
            row          = g_ptr_array_index(output_data, j);
            row[i].width = max_width + 1;
        }
    }
}

void
print_data(const NmcConfig     *nmc_config,
           NmcPagerData        *pager_data,
           const GArray        *indices,
           const char          *header_name,
           int                  indent,
           const NmcOutputData *out)
{
    guint i;

    for (i = 0; i < out->output_data->len; i++) {
        const NmcOutputField *field_values = g_ptr_array_index(out->output_data, i);

        print_required_fields(nmc_config,
                              pager_data,
                              field_values[0].flags,
                              indices,
                              header_name,
                              indent,
                              field_values);
    }
}

void
nmc_warn_if_version_mismatch(NMClient *client)
{
    const char *nm_ver;

    g_return_if_fail(client != NULL);

    if (!nm_client_get_nm_running(client))
        return;

    nm_ver = nm_client_get_version(client);
    if (!nm_streq0(nm_ver, VERSION)) {
        g_printerr(_("Warning: nmcli (%s) and NetworkManager (%s) versions don't match. "
                     "Restarting NetworkManager is advised.\n"),
                   VERSION,
                   nm_ver ? nm_ver : _("Unknown"));
    }
}
