[thirdparty/lldpd.git] / src / client / commands.c

/* -*- mode: c; c-file-style: "openbsd" -*- */
/*
 * Copyright (c) 2012 Vincent Bernat <bernat@luffy.cx>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include "client.h"
#include <string.h>
#include <sys/queue.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <libgen.h>

/**
 * An element of the environment (a key and a value).
 */
struct cmd_env_el {
        TAILQ_ENTRY(cmd_env_el) next; /**< Next environment element */
        const char *key;              /**< Key for this element */
        const char *value;            /**< Value for this element */
};

/**
 * A stack element.
 */
struct cmd_env_stack {
        TAILQ_ENTRY(cmd_env_stack) next; /**< Next element, down the stack */
        struct cmd_node *el;             /**< Stored element */
};

/**
 * Structure representing an environment for the current command.
 *
 * An environment is a list of values stored for use for the function executing
 * as well as the current command, the current position in the command and a
 * stack for cmd_node
 */
struct cmd_env {
        TAILQ_HEAD(, cmd_env_el) elements; /**< List of environment variables */
        TAILQ_HEAD(, cmd_env_stack) stack; /**< Stack */
        int argc;                          /**< Number of argument in the command */
        int argp;                          /**< Current argument */
        const char **argv;                 /**< Arguments */
};

/**
 * Structure representing a command node.
 *
 * Such a node contains a token accepted to enter the node (or @c NULL if there
 * is no token needed), a documentation string to present the user, a function
 * to validate the user input (or @c NULL if no function is needed) and a
 * function to execute when entering the node. Because we can enter a node just
 * by completing, the execution part should have no other effect than modifying
 * the environment, with the exception of execution on @c NEWLINE (which cannot
 * happen when completing).
 */
struct cmd_node {
        TAILQ_ENTRY(cmd_node) next; /**< Next sibling */

        const char *token; /**< Token to enter this cnode */
        const char *doc;   /**< Documentation string */
        int privileged;    /**< Privileged command? */
        int lock;          /**< Lock required for execution? */
        int hidden;        /**< Hidden command? */

        /**
         * Function validating entry in this node. Can be @c NULL.
         */
        int (*validate)(struct cmd_env *, const void *);
        /**
         * Function to execute when entering this node. May be @c NULL.
         *
         * This function can alter the environment
         */
        int (*execute)(struct lldpctl_conn_t *, struct writer *, struct cmd_env *,
            const void *);
        const void *arg; /**< Magic argument for the previous two functions */

        /* List of possible subentries */
        TAILQ_HEAD(, cmd_node) subentries; /* List of subnodes */
};

/**
 * Create a root node.
 *
 * @return the root node.
 */
struct cmd_node *
commands_root(void)
{
        struct cmd_node *new = calloc(1, sizeof(struct cmd_node));
        if (new == NULL) fatalx("lldpctl", "out of memory");
        TAILQ_INIT(&new->subentries);
        return new;
}

/**
 * Make a node accessible only to privileged users.
 *
 * @param node node to change privileges
 * @return the modified node
 *
 * The node is modified. It is returned to ease chaining.
 */
struct cmd_node *
commands_privileged(struct cmd_node *node)
{
        if (node) node->privileged = 1;
        return node;
}

/**
 * Make a node accessible only with a lock.
 *
 * @param node node to use lock to execute
 * @return the modified node
 *
 * The node is modified. It is returned to ease chaining.
 */
struct cmd_node *
commands_lock(struct cmd_node *node)
{
        if (node) node->lock = 1;
        return node;
}

/**
 * Hide a node from help or completion.
 *
 * @param node node to hide
 * @return the modified node
 *
 * The node is modified. It is returned to ease chaining.
 */
struct cmd_node *
commands_hidden(struct cmd_node *node)
{
        if (node) node->hidden = 1;
        return node;
}

/**
 * Create a new node acessible by any user.
 *
 * @param root  The node we want to attach this node.
 * @param token Token to enter this node. Or @c NULL if no token is needed.
 * @param doc   Documentation for this node.
 * @param validate Function that should return 1 if we can enter the node.
 * @param execute  Function that should return 1 on successful execution of this node.
 * @param arg      Magic argument for precedent functions.
 * @return  the newly created node
 */
struct cmd_node *
commands_new(struct cmd_node *root, const char *token, const char *doc,
    int (*validate)(struct cmd_env *, const void *),
    int (*execute)(struct lldpctl_conn_t *, struct writer *, struct cmd_env *,
        const void *),
    const void *arg)
{
        struct cmd_node *new = calloc(1, sizeof(struct cmd_node));
        if (new == NULL) fatalx("lldpctl", "out of memory");
        new->token = token;
        new->doc = doc;
        new->validate = validate;
        new->execute = execute;
        new->arg = arg;
        TAILQ_INIT(&new->subentries);
        TAILQ_INSERT_TAIL(&root->subentries, new, next);
        return new;
}

/**
 * Free a command tree.
 *
 * @param root The node we want to free.
 */
void
commands_free(struct cmd_node *root)
{
        struct cmd_node *subcmd, *subcmd_next;
        for (subcmd = TAILQ_FIRST(&root->subentries); subcmd != NULL;
             subcmd = subcmd_next) {
                subcmd_next = TAILQ_NEXT(subcmd, next);
                TAILQ_REMOVE(&root->subentries, subcmd, next);
                commands_free(subcmd);
        }
        free(root);
}

/**
 * Return the current argument in the environment. This can be @c NEWLINE or
 * @c NULL.
 *
 * @param env The environment.
 * @return current argument.
 */
const char *
cmdenv_arg(struct cmd_env *env)
{
        if (env->argp < env->argc) return env->argv[env->argp];
        if (env->argp == env->argc) return NEWLINE;
        return NULL;
}

/**
 * Get a value from the environment.
 *
 * @param env The environment.
 * @param key The key for the requested value.
 * @return @c NULL if not found or the requested value otherwise. If no value is
 *         associated, return the key.
 */
const char *
cmdenv_get(struct cmd_env *env, const char *key)
{
        struct cmd_env_el *el;
        TAILQ_FOREACH (el, &env->elements, next)
                if (!strcmp(el->key, key)) return el->value ? el->value : el->key;
        return NULL;
}

/**
 * Put a value in the environment.
 *
 * @param env The environment.
 * @param key The key for the value.
 * @param value The value.
 * @return 0 on success, -1 otherwise.
 */
int
cmdenv_put(struct cmd_env *env, const char *key, const char *value)
{
        struct cmd_env_el *el = malloc(sizeof(struct cmd_env_el));
        if (el == NULL) {
                log_warn("lldpctl",
                    "unable to allocate memory for new environment variable");
                return -1;
        }
        el->key = key;
        el->value = value;
        TAILQ_INSERT_TAIL(&env->elements, el, next);
        return 0;
}

/**
 * Pop some node from the execution stack.
 *
 * This allows to resume parsing on a previous state. Useful to call after
 * parsing optional arguments.
 *
 * @param env The environment.
 * @param n How many element we want to pop.
 * @return 0 on success, -1 otherwise.
 */
int
cmdenv_pop(struct cmd_env *env, int n)
{
        while (n-- > 0) {
                if (TAILQ_EMPTY(&env->stack)) {
                        log_warnx("lldpctl", "environment stack is empty");
                        return -1;
                }
                struct cmd_env_stack *first = TAILQ_FIRST(&env->stack);
                TAILQ_REMOVE(&env->stack, first, next);
                free(first);
        }
        return 0;
}

/**
 * Push some node on the execution stack.
 *
 * @param env The environment.
 * @param node The node to push.
 * @return 0 on success, -1 on error.
 */
static int
cmdenv_push(struct cmd_env *env, struct cmd_node *node)
{
        struct cmd_env_stack *el = malloc(sizeof(struct cmd_env_stack));
        if (el == NULL) {
                log_warn("lldpctl", "not enough memory to allocate a stack element");
                return -1;
        }
        el->el = node;
        TAILQ_INSERT_HEAD(&env->stack, el, next);
        return 0;
}

/**
 * Return the top of the stack, without poping it.
 *
 * @param env The environment.
 * @return the top element or @c NULL is the stack is empty.
 */
static struct cmd_node *
cmdenv_top(struct cmd_env *env)
{
        if (TAILQ_EMPTY(&env->stack)) return NULL;
        return TAILQ_FIRST(&env->stack)->el;
}

/**
 * Free execution environment.
 *
 * @param env The environment.
 */
static void
cmdenv_free(struct cmd_env *env)
{
        while (!TAILQ_EMPTY(&env->stack))
                cmdenv_pop(env, 1);

        struct cmd_env_el *first;
        while (!TAILQ_EMPTY(&env->elements)) {
                first = TAILQ_FIRST(&env->elements);
                TAILQ_REMOVE(&env->elements, first, next);
                free(first);
        }
}

struct candidate_word {
        TAILQ_ENTRY(candidate_word) next;
        const char *word;
        const char *doc;
        int hidden;
};

/**
 * Execute or complete a command from the given node.
 *
 * @param conn    Connection to lldpd.
 * @param w       Writer for output.
 * @param root    Root node we want to start from.
 * @param argc    Number of arguments.
 * @param argv    Array of arguments.
 * @param word    Completed word. Or NULL when no completion is required.
 * @param all     When completing, display possible completions even if only one choice
 * is possible.
 * @param priv    Is the current user privileged?
 * @return 0 on success, -1 otherwise.
 */
static int
_commands_execute(struct lldpctl_conn_t *conn, struct writer *w, struct cmd_node *root,
    int argc, const char **argv, char **word, int all, int priv)
{
        int n, rc = 0, completion = (word != NULL);
        int help = 0;     /* Are we asking for help? */
        int complete = 0; /* Are we asking for possible completions? */
        int needlock = 0; /* Do we need a lock? */
        struct cmd_env env = { .elements = TAILQ_HEAD_INITIALIZER(env.elements),
                .stack = TAILQ_HEAD_INITIALIZER(env.stack),
                .argc = argc,
                .argv = argv,
                .argp = 0 };
        static int lockfd = -1;
        static char *lockname = NULL; /* Name of lockfile */
        cmdenv_push(&env, root);
        if (!completion)
                for (n = 0; n < argc; n++)
                        log_debug("lldpctl", "argument %02d: `%s`", n, argv[n]);
        if (completion) *word = NULL;

#define CAN_EXECUTE(candidate)                     \
  ((!candidate->privileged || priv || complete) && \
      (!candidate->validate || candidate->validate(&env, candidate->arg) == 1))

        /* When completion is in progress, we use the same algorithm than for
         * execution until we reach the cursor position. */
        struct cmd_node *current = NULL;
        while ((current = cmdenv_top(&env))) {
                if (!completion) {
                        help = !!cmdenv_get(&env, "help"); /* Are we asking for help? */
                        complete = !!cmdenv_get(&env, "complete"); /* Or completion? */
                }

                struct cmd_node *candidate, *best = NULL;
                const char *token = (env.argp < env.argc)        ? env.argv[env.argp] :
                    (env.argp == env.argc && !help && !complete) ? NEWLINE :
                                                                   NULL;
                if (token == NULL || (completion && env.argp == env.argc - 1)) goto end;
                if (!completion)
                        log_debug("lldpctl", "process argument %02d: `%s`", env.argp,
                            token);
                TAILQ_FOREACH (candidate, &current->subentries, next) {
                        if (candidate->token &&
                            !strncmp(candidate->token, token, strlen(token)) &&
                            CAN_EXECUTE(candidate)) {
                                if (candidate->token &&
                                    !strcmp(candidate->token, token)) {
                                        /* Exact match */
                                        best = candidate;
                                        needlock = needlock || candidate->lock;
                                        break;
                                }
                                if (!best)
                                        best = candidate;
                                else {
                                        if (!completion)
                                                log_warnx("lldpctl",
                                                    "ambiguous token: %s (%s or %s)",
                                                    token, candidate->token,
                                                    best->token);
                                        rc = -1;
                                        goto end;
                                }
                        }
                }
                if (!best) {
                        /* Take first that validate */
                        TAILQ_FOREACH (candidate, &current->subentries, next) {
                                if (!candidate->token && CAN_EXECUTE(candidate)) {
                                        best = candidate;
                                        needlock = needlock || candidate->lock;
                                        break;
                                }
                        }
                }
                if (!best && env.argp == env.argc) goto end;
                if (!best) {
                        if (!completion)
                                log_warnx("lldpctl",
                                    "unknown command from argument %d: `%s`",
                                    env.argp + 1, token);
                        rc = -1;
                        goto end;
                }

                /* Push and execute */
                cmdenv_push(&env, best);
                if (best->execute) {
                        if (needlock) {
                                if (lockfd == -1) {
                                        if (lockname == NULL &&
                                            asprintf(&lockname, "%s.lock", ctlname) ==
                                                -1) {
                                                log_warnx("lldpctl",
                                                    "not enough memory to build lock filename");
                                                rc = -1;
                                                goto end;
                                        }
                                        log_debug("lldpctl", "open %s for locking",
                                            lockname);
                                        if ((lockfd = open(lockname, O_RDWR)) == -1) {
                                                log_warn("lldpctl",
                                                    "cannot open lock %s", lockname);
                                                rc = -1;
                                                goto end;
                                        }
                                }
                                if (lockf(lockfd, F_LOCK, 0) == -1) {
                                        log_warn("lldpctl", "cannot get lock on %s",
                                            lockname);
                                        rc = -1;
                                        close(lockfd);
                                        lockfd = -1;
                                        goto end;
                                }
                        }
                        rc = best->execute(conn, w, &env, best->arg) != 1 ? -1 : rc;
                        if (needlock && lockf(lockfd, F_ULOCK, 0) == -1) {
                                log_warn("lldpctl", "cannot unlock %s", lockname);
                                close(lockfd);
                                lockfd = -1;
                        }
                        if (rc == -1) goto end;
                }
                env.argp++;
        }
end:
        if (!completion && !help && !complete) {
                if (rc == 0 && env.argp != env.argc + 1) {
                        log_warnx("lldpctl", "incomplete command");
                        rc = -1;
                }
        } else if (rc == 0 && (env.argp == env.argc - 1 || help || complete)) {
                /* We need to complete. Let's build the list of candidate words. */
                struct cmd_node *candidate = NULL;
                size_t maxl = 10;                   /* Max length of a word */
                TAILQ_HEAD(, candidate_word) words; /* List of subnodes */
                TAILQ_INIT(&words);
                current = cmdenv_top(&env);
                if (!TAILQ_EMPTY(&current->subentries)) {
                        TAILQ_FOREACH (candidate, &current->subentries, next) {
                                if ((!candidate->token || help || complete ||
                                        !strncmp(env.argv[env.argc - 1],
                                            candidate->token,
                                            strlen(env.argv[env.argc - 1]))) &&
                                    CAN_EXECUTE(candidate)) {
                                        struct candidate_word *cword =
                                            malloc(sizeof(struct candidate_word));
                                        if (!cword) break;
                                        cword->word = candidate->token;
                                        cword->doc = candidate->doc;
                                        cword->hidden = candidate->hidden;
                                        if (cword->word && strlen(cword->word) > maxl)
                                                maxl = strlen(cword->word);
                                        TAILQ_INSERT_TAIL(&words, cword, next);
                                }
                        }
                }
                if (!TAILQ_EMPTY(&words)) {
                        /* Search if there is a common prefix, then return it. */
                        char prefix[maxl + 2]; /* Extra space may be added at the end */
                        struct candidate_word *cword, *cword_next;
                        memset(prefix, 0, maxl + 2);
                        for (size_t n = 0; n < maxl; n++) {
                                int c = 1; /* Set to 0 to exit outer loop */
                                TAILQ_FOREACH (cword, &words, next) {
                                        c = 0;
                                        if (cword->hidden) continue;
                                        if (cword->word == NULL) break;
                                        if (!strcmp(cword->word, NEWLINE)) break;
                                        if (strlen(cword->word) == n) break;
                                        if (prefix[n] == '\0')
                                                prefix[n] = cword->word[n];
                                        else if (prefix[n] != cword->word[n])
                                                break;
                                        c = 1;
                                }
                                if (c == 0) {
                                        prefix[n] = '\0';
                                        break;
                                }
                        }
                        /* If the prefix is complete, add a space, otherwise,
                         * just return it as is. */
                        if (!all && !help && !complete && strcmp(prefix, NEWLINE) &&
                            strlen(prefix) > 0 &&
                            strlen(env.argv[env.argc - 1]) < strlen(prefix)) {
                                TAILQ_FOREACH (cword, &words, next) {
                                        if (cword->word &&
                                            !strcmp(prefix, cword->word)) {
                                                prefix[strlen(prefix)] = ' ';
                                                break;
                                        }
                                }
                                *word = strdup(prefix);
                        } else {
                                /* No common prefix, print possible completions */
                                if (!complete)
                                        fprintf(stderr, "\n-- \033[1;34m%s\033[0m\n",
                                            current->doc ? current->doc : "Help");
                                TAILQ_FOREACH (cword, &words, next) {
                                        if (cword->hidden) continue;

                                        char fmt[100];
                                        if (!complete) {
                                                snprintf(fmt, sizeof(fmt),
                                                    "%s%%%ds%s  %%s\n", "\033[1m",
                                                    (int)maxl, "\033[0m");
                                                fprintf(stderr, fmt,
                                                    cword->word ? cword->word : "WORD",
                                                    cword->doc ? cword->doc : "...");
                                        } else {
                                                if (!cword->word ||
                                                    !strcmp(cword->word, NEWLINE))
                                                        continue;
                                                fprintf(stdout, "%s %s\n",
                                                    cword->word ? cword->word : "WORD",
                                                    cword->doc ? cword->doc : "...");
                                        }
                                }
                        }
                        for (cword = TAILQ_FIRST(&words); cword != NULL;
                             cword = cword_next) {
                                cword_next = TAILQ_NEXT(cword, next);
                                TAILQ_REMOVE(&words, cword, next);
                                free(cword);
                        }
                }
        }
        cmdenv_free(&env);
        return rc;
}

/**
 * Complete the given command.
 */
char *
commands_complete(struct cmd_node *root, int argc, const char **argv, int all,
    int privileged)
{
        char *word = NULL;
        if (_commands_execute(NULL, NULL, root, argc, argv, &word, all, privileged) ==
            0)
                return word;
        return NULL;
}

/**
 * Execute the given commands.
 */
int
commands_execute(struct lldpctl_conn_t *conn, struct writer *w, struct cmd_node *root,
    int argc, const char **argv, int privileged)
{
        return _commands_execute(conn, w, root, argc, argv, NULL, 0, privileged);
}

/**
 * Check if the environment does not contain the given key.
 *
 * @param env The environment.
 * @param key The key to search for.
 * @return 1 if the environment does not contain the key. 0 otherwise.
 */
int
cmd_check_no_env(struct cmd_env *env, const void *key)
{
        return cmdenv_get(env, (const char *)key) == NULL;
}

/**
 * Check if the environment does contain the given key.
 *
 * @param env The environment.
 * @param key The key to search for. Can be a comma separated list.
 * @return 1 if the environment does contain the key. 0 otherwise.
 */
int
cmd_check_env(struct cmd_env *env, const void *key)
{
        struct cmd_env_el *el;
        const char *list = key;
        int count = 0;
        TAILQ_FOREACH (el, &env->elements, next) {
                if (contains(list, el->key)) count++;
        }
        while ((list = strchr(list, ','))) {
                list++;
                count--;
        }
        return (count == 1);
}

/**
 * Store the given key in the environment.
 *
 * @param conn The connection.
 * @param w    The writer (not used).
 * @param env The environment.
 * @param key The key to store.
 * @return 1 if the key was stored
 */
int
cmd_store_env(struct lldpctl_conn_t *conn, struct writer *w, struct cmd_env *env,
    const void *key)
{
        return cmdenv_put(env, key, NULL) != -1;
}

/**
 * Store the given key in the environment and pop one element from the stack.
 *
 * @param conn The connection.
 * @param w    The writer (not used).
 * @param env The environment.
 * @param key The key to store.
 * @return 1 if the key was stored
 */
int
cmd_store_env_and_pop(struct lldpctl_conn_t *conn, struct writer *w,
    struct cmd_env *env, const void *key)
{
        return (cmd_store_env(conn, w, env, key) != -1 && cmdenv_pop(env, 1) != -1);
}

/**
 * Store the given key with a value being the current keyword in the environment
 * and pop X elements from the stack.
 *
 * @param conn The connection.
 * @param w    The writer (not used).
 * @param env The environment.
 * @param key The key to store.
 * @return 1 if the key was stored
 */
int
cmd_store_env_value_and_pop(struct lldpctl_conn_t *conn, struct writer *w,
    struct cmd_env *env, const void *key)
{
        return (
            cmdenv_put(env, key, cmdenv_arg(env)) != -1 && cmdenv_pop(env, 1) != -1);
}
int
cmd_store_env_value_and_pop2(struct lldpctl_conn_t *conn, struct writer *w,
    struct cmd_env *env, const void *key)
{
        return (
            cmdenv_put(env, key, cmdenv_arg(env)) != -1 && cmdenv_pop(env, 2) != -1);
}
int
cmd_store_env_value(struct lldpctl_conn_t *conn, struct writer *w, struct cmd_env *env,
    const void *key)
{
        return (cmdenv_put(env, key, cmdenv_arg(env)) != -1);
}
int
cmd_store_env_value_and_pop3(struct lldpctl_conn_t *conn, struct writer *w,
    struct cmd_env *env, const void *key)
{
        return (
            cmdenv_put(env, key, cmdenv_arg(env)) != -1 && cmdenv_pop(env, 3) != -1);
}
int
cmd_store_something_env_value_and_pop2(const char *what, struct cmd_env *env,
    const void *value)
{
        return (cmdenv_put(env, what, value) != -1 && cmdenv_pop(env, 2) != -1);
}
int
cmd_store_something_env_value(const char *what, struct cmd_env *env, const void *value)
{
        return (cmdenv_put(env, what, value) != -1);
}

/**
 * Provide an iterator on all interfaces contained in "ports".
 *
 * @warning This function is not reentrant. It uses static variables to keep
 * track of ports that have already been provided. Moreover, to release all
 * resources, the iterator should be used until its end.
 *
 * @param conn The connection.
 * @param env  The environment.
 * @return The next interface in the set of ports (or in all ports if no `ports`
 *         variable is present in the environment)
 */
lldpctl_atom_t *
cmd_iterate_on_interfaces(struct lldpctl_conn_t *conn, struct cmd_env *env)
{
        static lldpctl_atom_iter_t *iter = NULL;
        static lldpctl_atom_t *iface_list = NULL;
        static lldpctl_atom_t *iface = NULL;
        const char *interfaces = cmdenv_get(env, "ports");

        do {
                if (iter == NULL) {
                        iface_list = lldpctl_get_interfaces(conn);
                        if (!iface_list) {
                                log_warnx("lldpctl",
                                    "not able to get the list of interfaces. %s",
                                    lldpctl_last_strerror(conn));
                                return NULL;
                        }
                        iter = lldpctl_atom_iter(iface_list);
                        if (!iter) return NULL;
                } else {
                        iter = lldpctl_atom_iter_next(iface_list, iter);
                        if (iface) {
                                lldpctl_atom_dec_ref(iface);
                                iface = NULL;
                        }
                        if (!iter) {
                                lldpctl_atom_dec_ref(iface_list);
                                return NULL;
                        }
                }

                iface = lldpctl_atom_iter_value(iface_list, iter);
        } while (interfaces &&
            !contains(interfaces,
                lldpctl_atom_get_str(iface, lldpctl_k_interface_name)));

        return iface;
}

/**
 * Provide an iterator on all ports contained in "ports", as well as the
 * default port.
 *
 * @warning This function is not reentrant. It uses static variables to keep
 * track of ports that have already been provided. Moreover, to release all
 * resources, the iterator should be used until its end.
 *
 * @param conn The connection.
 * @param env  The environment.
 * @param name Name of the interface (for logging purpose)
 * @return The next interface in the set of ports (or in all ports if no `ports`
 *         variable is present in the environment), including the default port
 *         if no `ports` variable is present in the environment.
 */
lldpctl_atom_t *
cmd_iterate_on_ports(struct lldpctl_conn_t *conn, struct cmd_env *env,
    const char **name)
{
        static int put_default = 0;
        static lldpctl_atom_t *last_port = NULL;
        const char *interfaces = cmdenv_get(env, "ports");

        if (last_port) {
                lldpctl_atom_dec_ref(last_port);
                last_port = NULL;
        }
        if (!put_default) {
                lldpctl_atom_t *iface = cmd_iterate_on_interfaces(conn, env);
                if (iface) {
                        *name = lldpctl_atom_get_str(iface, lldpctl_k_interface_name);
                        last_port = lldpctl_get_port(iface);
                        return last_port;
                }
                if (!interfaces) {
                        put_default = 1;
                        *name = "(default)";
                        last_port = lldpctl_get_default_port(conn);
                        return last_port;
                }
                return NULL;
        } else {
                put_default = 0;
                return NULL;
        }
}

/**
 * Restrict the command to some ports.
 */
void
cmd_restrict_ports(struct cmd_node *root)
{
        /* Restrict to some ports. */
        commands_new(commands_new(root, "ports", "Restrict configuration to some ports",
                         cmd_check_no_env, NULL, "ports"),
            NULL,
            "Restrict configuration to the specified ports (comma-separated list)",
            NULL, cmd_store_env_value_and_pop2, "ports");
}

/**
 * Restrict the command to specific protocol
 */
void
cmd_restrict_protocol(struct cmd_node *root)
{
        /* Restrict to some ports. */
        commands_new(commands_new(root, "protocol", "Restrict to specific protocol",
                         cmd_check_no_env, NULL, "protocol"),
            NULL, "Restrict display to the specified protocol", NULL,
            cmd_store_env_value_and_pop2, "protocol");
}