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

/* -*- mode: c; c-file-style: "openbsd" -*- */
/*
 * Copyright (c) 2008 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.
 */

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <arpa/inet.h>
#include <histedit.h>
#include <libgen.h>

#include "client.h"

#ifdef HAVE___PROGNAME
extern const char	*__progname;
#else
# define __progname "lldpcli"
#endif

/* Global for completion */
static struct cmd_node *root = NULL;

static void
usage()
{
	fprintf(stderr, "Usage:   %s [OPTIONS ...] [COMMAND ...]\n", __progname);
	fprintf(stderr, "Version: %s\n", PACKAGE_STRING);

	fprintf(stderr, "\n");

	fprintf(stderr, "-d          Enable more debugging information.\n");
	fprintf(stderr, "-f format   Choose output format (plain, keyvalue or xml).\n");

	fprintf(stderr, "\n");

	fprintf(stderr, "see manual page lldpcli(8) for more information\n");
	exit(1);
}

static int
is_privileged()
{
	return (!(getuid() != geteuid() || getgid() != getegid()));
}

static char*
prompt(EditLine *el)
{
	int privileged = is_privileged();
	if (privileged)
		return "[lldpcli] # ";
	return "[lldpcli] $ ";
}

static int must_exit = 0;
/**
 * Exit the interpreter.
 */
static int
cmd_exit(struct lldpctl_conn_t *conn, struct writer *w,
    struct cmd_env *env, void *arg)
{
	log_info("lldpctl", "quit lldpcli");
	must_exit = 1;
	return 1;
}

/**
 * Send an "update" request.
 */
static int
cmd_update(struct lldpctl_conn_t *conn, struct writer *w,
    struct cmd_env *env, void *arg)
{
	log_info("lldpctl", "ask for global update");

	lldpctl_atom_t *config = lldpctl_get_configuration(conn);
	if (config == NULL) {
		log_warnx("lldpctl", "unable to get configuration from lldpd. %s",
		    lldpctl_last_strerror(conn));
		return 0;
	}
	if (lldpctl_atom_set_int(config,
		lldpctl_k_config_tx_interval, -1) == NULL) {
		log_warnx("lldpctl", "unable to ask lldpd for immediate retransmission. %s",
		    lldpctl_last_strerror(conn));
		lldpctl_atom_dec_ref(config);
		return 0;
	}
	log_info("lldpctl", "immediate retransmission requested successfuly");
	lldpctl_atom_dec_ref(config);
	return 1;
}

static unsigned char
_cmd_complete(EditLine *el, int ch, int all)
{
	int rc = CC_ERROR;
	Tokenizer *eltok;
	if ((eltok = tok_init(NULL)) == NULL)
		goto end;

	const LineInfo *li = el_line(el);

	const char **argv;
	char *compl;
	int argc, cursorc, cursoro;
	if (tok_line(eltok, li, &argc, &argv, &cursorc, &cursoro) != 0)
		goto end;
	compl = commands_complete(root, argc, argv, cursorc, cursoro, all);
	if (compl) {
		el_deletestr(el, cursoro);
		if (el_insertstr(el, compl) == -1) {
			free(compl);
			goto end;
		}
		free(compl);
		rc = CC_REDISPLAY;
		goto end;
	}
	/* No completion or several completion available. We beep. */
	el_beep(el);
	rc = CC_REDISPLAY;
end:
	if (eltok) tok_end(eltok);
	return rc;
}

static unsigned char
cmd_complete(EditLine *el, int ch)
{
	return _cmd_complete(el, ch, 0);
}

static unsigned char
cmd_help(EditLine *el, int ch)
{
	return _cmd_complete(el, ch, 1);
}

static struct cmd_node*
register_commands()
{
	root = commands_root();
	register_commands_show(root);
	register_commands_watch(root);
	if (is_privileged()) {
		commands_new(
			commands_new(root, "update", "Update information and send LLDPU on all ports",
			    NULL, NULL, NULL),
			NEWLINE, "Update information and send LLDPU on all ports",
			NULL, cmd_update, NULL);
		register_commands_configure(root);
	}
	commands_new(
		commands_new(root, "exit", "Exit interpreter", NULL, NULL, NULL),
		NEWLINE, "Exit interpreter", NULL, cmd_exit, NULL);
	return root;
}

static int
is_lldpctl(const char *name)
{
	static int last_result = -1;
	if (last_result == -1 && name) {
		char *basec = strdup(name);
		if (!basec) return 0;
		char *bname = basename(basec);
		last_result = (!strcmp(bname, "lldpctl"));
		free(basec);
	}
	return (last_result == -1)?0:last_result;
}

int
main(int argc, char *argv[])
{
	int ch, debug = 1, rc = EXIT_FAILURE;
	char *fmt = "plain";
	lldpctl_conn_t *conn;
	struct writer *w;

	EditLine  *el = NULL;
	History   *elhistory = NULL;
	HistEvent  elhistev;
	Tokenizer *eltok = NULL;

	char *interfaces = NULL;

	/* Get and parse command line options */
	while ((ch = getopt(argc, argv, "hdvf:")) != -1) {
		switch (ch) {
		case 'h':
			usage();
			break;
		case 'd':
			debug++;
			break;
		case 'v':
			fprintf(stdout, "%s\n", PACKAGE_VERSION);
			exit(0);
			break;
		case 'f':
			fmt = optarg;
			break;
		default:
			usage();
		}
	}

	log_init(debug, __progname);

	/* Register commands */
	root = register_commands();

	if (is_lldpctl(argv[0])) {
		for (int i = optind; i < argc; i++) {
			char *prev = interfaces;
			if (asprintf(&interfaces, "%s%s%s",
				prev?prev:"", prev?",":"", argv[i]) == -1) {
				log_warnx("lldpctl", "not enough memory to build list of interfaces");
				goto end;
			}
			free(prev);
		}
		must_exit = 1;
		goto skipeditline;
	} else {
		if (optind < argc) {
			/* More arguments! */
			must_exit = 1;
		}
	}

	/* Init editline */
	log_debug("lldpctl", "init editline");
	el = el_init("lldpctl", stdin, stdout, stderr);
	if (el == NULL) {
		log_warnx("lldpctl", "unable to setup editline");
		goto end;
	}
	el_set(el, EL_PROMPT, prompt);
	el_set(el, EL_SIGNAL, 1);
	el_set(el, EL_EDITOR, "emacs");
	/* If on a TTY, setup completion */
	if (isatty(STDERR_FILENO)) {
		el_set(el, EL_ADDFN, "command_complete",
		    "Execute completion", cmd_complete);
		el_set(el, EL_ADDFN, "command_help",
		    "Show completion", cmd_help);
		el_set(el, EL_BIND, "^I", "command_complete", NULL);
		el_set(el, EL_BIND, "?", "command_help", NULL);
	}

	/* Init history */
	elhistory = history_init();
	if (elhistory == NULL) {
		log_warnx("lldpctl", "unable to enable history");
	} else {
		history(elhistory, &elhistev, H_SETSIZE, 800);
		el_set(el, EL_HIST, history, elhistory);
	}

	/* Init tokenizer */
	eltok = tok_init(NULL);
	if (eltok == NULL) {
		log_warnx("lldpctl", "unable to initialize tokenizer");
		goto end;
	}

skipeditline:
	/* Make a connection */
	log_debug("lldpctl", "connect to lldpd");
	conn = lldpctl_new(NULL, NULL, NULL);
	if (conn == NULL)
		exit(EXIT_FAILURE);

	do {
		const char *line;
		const char **cargv;
		int count, n, cargc;

		if (!is_lldpctl(NULL) && (optind >= argc)) {
			/* Read a new line. */
			line = el_gets(el, &count);
			if (line == NULL) break;

			/* Tokenize it */
			log_debug("lldpctl", "tokenize command line");
			n = tok_str(eltok, line, &cargc, &cargv);
			switch (n) {
			case -1:
				log_warnx("lldpctl", "internal error while tokenizing");
				goto end;
			case 1:
			case 2:
			case 3:
				/* TODO: handle multiline statements */
				log_warnx("lldpctl", "unmatched quotes");
				tok_reset(eltok);
				continue;
			}
			if (cargc == 0) {
				tok_reset(eltok);
				continue;
			}
			if (elhistory) history(elhistory, &elhistev, H_ENTER, line);
		}

		/* Init output formatter */
		if      (strcmp(fmt, "plain")    == 0) w = txt_init(stdout);
		else if (strcmp(fmt, "keyvalue") == 0) w = kv_init(stdout);
#ifdef USE_XML
		else if (strcmp(fmt, "xml")      == 0) w = xml_init(stdout);
#endif
#ifdef USE_JSON
		else if (strcmp(fmt, "json")     == 0) w = json_init(stdout);
#endif
		else w = txt_init(stdout);

		if (is_lldpctl(NULL)) {
			if (!interfaces) {
				cargv = (const char*[]){ "show", "neighbors", "details" };
				cargc = 3;
			} else {
				cargv = (const char*[]){ "show", "neighbors", "ports", interfaces, "details" };
				cargc = 5;
			}
		} else if (optind < argc) {
			cargv = (const char **)argv;
			cargv = &cargv[optind];
			cargc = argc - optind;
		}

		/* Execute command */
		if (commands_execute(conn, w,
			root, cargc, cargv) != 0)
			log_info("lldpctl", "an error occurred while executing last command");
		w->finish(w);

		if (eltok) tok_reset(eltok);
	} while (!must_exit);

	rc = EXIT_SUCCESS;
end:
	if (conn) lldpctl_release(conn);
	if (eltok) tok_end(eltok);
	if (elhistory) history_end(elhistory);
	if (el) el_end(el);
	if (root) commands_free(root);
	free(interfaces);
	return rc;
}
Commit	Line	Data
4b292b55 VB	1	/* -- mode: c; c-file-style: "openbsd" -- */
	2	/*
	3	* Copyright (c) 2008 Vincent Bernat <bernat@luffy.cx>
	4	*
	5	* Permission to use, copy, modify, and/or distribute this software for any
	6	* purpose with or without fee is hereby granted, provided that the above
	7	* copyright notice and this permission notice appear in all copies.
	8	*
	9	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	10	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	11	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	12	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	13	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	14	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	15	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	16	*/
	17
fe80711e	18	#define _GNU_SOURCE
4b292b55 VB	19	#include <stdio.h>
	20	#include <stdlib.h>
	21	#include <unistd.h>
	22	#include <time.h>
	23	#include <errno.h>
4e5f34c5	24	#include <string.h>
4b292b55 VB	25	#include <sys/types.h>
	26	#include <sys/socket.h>
	27	#include <sys/un.h>
	28	#include <arpa/inet.h>
9a775667	29	#include <histedit.h>
fe80711e	30	#include <libgen.h>
4b292b55	31
4b292b55 VB	32	#include "client.h"
4b292b55 VB	33
4b292b55 VB	34	#ifdef HAVE___PROGNAME
	35	extern const char *__progname;
	36	#else
fe80711e	37	# define __progname "lldpcli"
4b292b55 VB	38	#endif
4b292b55 VB	39
9a775667 VB	40	/* Global for completion */
9a775667 VB	41	static struct cmd_node *root = NULL;
4b292b55 VB	42
4b292b55 VB	43	static void
9a775667	44	usage()
4b292b55	45	{
9a775667	46	fprintf(stderr, "Usage: %s [OPTIONS ...] [COMMAND ...]\n", __progname);
4b292b55 VB	47	fprintf(stderr, "Version: %s\n", PACKAGE_STRING);
	48
	49	fprintf(stderr, "\n");
	50
	51	fprintf(stderr, "-d Enable more debugging information.\n");
4b292b55	52	fprintf(stderr, "-f format Choose output format (plain, keyvalue or xml).\n");
4b292b55 VB	53
	54	fprintf(stderr, "\n");
	55
fe80711e	56	fprintf(stderr, "see manual page lldpcli(8) for more information\n");
4b292b55 VB	57	exit(1);
	58	}
	59
9a775667 VB	60	static int
	61	is_privileged()
	62	{
	63	return (!(getuid() != geteuid() \|\| getgid() != getegid()));
	64	}
	65
	66	static char*
	67	prompt(EditLine *el)
	68	{
	69	int privileged = is_privileged();
	70	if (privileged)
fe80711e VB	71	return "[lldpcli] # ";
fe80711e VB	72	return "[lldpcli] $ ";
9a775667 VB	73	}
	74
	75	static int must_exit = 0;
	76	/**
	77	* Exit the interpreter.
	78	*/
	79	static int
	80	cmd_exit(struct lldpctl_conn_t conn, struct writer w,
	81	struct cmd_env env, void arg)
4e90a9e0	82	{
fe80711e	83	log_info("lldpctl", "quit lldpcli");
9a775667 VB	84	must_exit = 1;
	85	return 1;
	86	}
	87
	88	/**
	89	* Send an "update" request.
	90	*/
	91	static int
	92	cmd_update(struct lldpctl_conn_t conn, struct writer w,
	93	struct cmd_env env, void arg)
	94	{
	95	log_info("lldpctl", "ask for global update");
	96
	97	lldpctl_atom_t *config = lldpctl_get_configuration(conn);
	98	if (config == NULL) {
	99	log_warnx("lldpctl", "unable to get configuration from lldpd. %s",
	100	lldpctl_last_strerror(conn));
	101	return 0;
4e90a9e0	102	}
9a775667 VB	103	if (lldpctl_atom_set_int(config,
	104	lldpctl_k_config_tx_interval, -1) == NULL) {
	105	log_warnx("lldpctl", "unable to ask lldpd for immediate retransmission. %s",
	106	lldpctl_last_strerror(conn));
	107	lldpctl_atom_dec_ref(config);
	108	return 0;
4e90a9e0	109	}
9a775667 VB	110	log_info("lldpctl", "immediate retransmission requested successfuly");
	111	lldpctl_atom_dec_ref(config);
	112	return 1;
	113	}
	114
	115	static unsigned char
	116	_cmd_complete(EditLine *el, int ch, int all)
	117	{
	118	int rc = CC_ERROR;
	119	Tokenizer *eltok;
	120	if ((eltok = tok_init(NULL)) == NULL)
	121	goto end;
	122
	123	const LineInfo *li = el_line(el);
	124
	125	const char **argv;
	126	char *compl;
	127	int argc, cursorc, cursoro;
	128	if (tok_line(eltok, li, &argc, &argv, &cursorc, &cursoro) != 0)
	129	goto end;
	130	compl = commands_complete(root, argc, argv, cursorc, cursoro, all);
	131	if (compl) {
	132	el_deletestr(el, cursoro);
	133	if (el_insertstr(el, compl) == -1) {
	134	free(compl);
	135	goto end;
	136	}
	137	free(compl);
	138	rc = CC_REDISPLAY;
	139	goto end;
	140	}
	141	/* No completion or several completion available. We beep. */
	142	el_beep(el);
	143	rc = CC_REDISPLAY;
	144	end:
	145	if (eltok) tok_end(eltok);
	146	return rc;
	147	}
	148
	149	static unsigned char
	150	cmd_complete(EditLine *el, int ch)
	151	{
	152	return _cmd_complete(el, ch, 0);
	153	}
	154
	155	static unsigned char
	156	cmd_help(EditLine *el, int ch)
	157	{
	158	return _cmd_complete(el, ch, 1);
	159	}
	160
	161	static struct cmd_node*
	162	register_commands()
	163	{
	164	root = commands_root();
	165	register_commands_show(root);
	166	register_commands_watch(root);
	167	if (is_privileged()) {
	168	commands_new(
	169	commands_new(root, "update", "Update information and send LLDPU on all ports",
	170	NULL, NULL, NULL),
	171	NEWLINE, "Update information and send LLDPU on all ports",
	172	NULL, cmd_update, NULL);
	173	register_commands_configure(root);
174	}
175	commands_new(
176	commands_new(root, "exit", "Exit interpreter", NULL, NULL, NULL),
177	NEWLINE, "Exit interpreter", NULL, cmd_exit, NULL);
178	return root;
4e90a9e0 VB	179	}
4e90a9e0 VB	180
fe80711e VB	181	static int
	182	is_lldpctl(const char *name)
	183	{
	184	static int last_result = -1;
	185	if (last_result == -1 && name) {
	186	char *basec = strdup(name);
	187	if (!basec) return 0;
	188	char *bname = basename(basec);
	189	last_result = (!strcmp(bname, "lldpctl"));
	190	free(basec);
	191	}
	192	return (last_result == -1)?0:last_result;
	193	}
	194
4b292b55 VB	195	int
	196	main(int argc, char *argv[])
	197	{
9a775667	198	int ch, debug = 1, rc = EXIT_FAILURE;
4e90a9e0	199	char *fmt = "plain";
4b292b55	200	lldpctl_conn_t *conn;
9a775667 VB	201	struct writer *w;
9a775667 VB	202
fe80711e VB	203	EditLine *el = NULL;
fe80711e VB	204	History *elhistory = NULL;
9a775667	205	HistEvent elhistev;
fe80711e VB	206	Tokenizer *eltok = NULL;
	207
	208	char *interfaces = NULL;
4b292b55 VB	209
4b292b55 VB	210	/* Get and parse command line options */
9a775667	211	while ((ch = getopt(argc, argv, "hdvf:")) != -1) {
4b292b55 VB	212	switch (ch) {
	213	case 'h':
	214	usage();
	215	break;
	216	case 'd':
	217	debug++;
	218	break;
	219	case 'v':
	220	fprintf(stdout, "%s\n", PACKAGE_VERSION);
	221	exit(0);
	222	break;
4b292b55 VB	223	case 'f':
	224	fmt = optarg;
	225	break;
4b292b55 VB	226	default:
	227	usage();
	228	}
	229	}
	230
	231	log_init(debug, __progname);
	232
9a775667 VB	233	/* Register commands */
	234	root = register_commands();
	235
fe80711e VB	236	if (is_lldpctl(argv[0])) {
	237	for (int i = optind; i < argc; i++) {
	238	char *prev = interfaces;
	239	if (asprintf(&interfaces, "%s%s%s",
	240	prev?prev:"", prev?",":"", argv[i]) == -1) {
	241	log_warnx("lldpctl", "not enough memory to build list of interfaces");
	242	goto end;
	243	}
	244	free(prev);
	245	}
	246	must_exit = 1;
	247	goto skipeditline;
a8be34ba VB	248	} else {
	249	if (optind < argc) {
	250	/* More arguments! */
	251	must_exit = 1;
	252	}
fe80711e VB	253	}
fe80711e VB	254
9a775667 VB	255	/* Init editline */
	256	log_debug("lldpctl", "init editline");
	257	el = el_init("lldpctl", stdin, stdout, stderr);
	258	if (el == NULL) {
	259	log_warnx("lldpctl", "unable to setup editline");
	260	goto end;
	261	}
	262	el_set(el, EL_PROMPT, prompt);
fdc876d6	263	el_set(el, EL_SIGNAL, 1);
9a775667 VB	264	el_set(el, EL_EDITOR, "emacs");
	265	/* If on a TTY, setup completion */
	266	if (isatty(STDERR_FILENO)) {
	267	el_set(el, EL_ADDFN, "command_complete",
	268	"Execute completion", cmd_complete);
	269	el_set(el, EL_ADDFN, "command_help",
	270	"Show completion", cmd_help);
	271	el_set(el, EL_BIND, "^I", "command_complete", NULL);
	272	el_set(el, EL_BIND, "?", "command_help", NULL);
4b292b55 VB	273	}
4b292b55 VB	274
9a775667 VB	275	/* Init history */
	276	elhistory = history_init();
	277	if (elhistory == NULL) {
	278	log_warnx("lldpctl", "unable to enable history");
	279	} else {
	280	history(elhistory, &elhistev, H_SETSIZE, 800);
	281	el_set(el, EL_HIST, history, elhistory);
4e90a9e0 VB	282	}
4e90a9e0 VB	283
9a775667 VB	284	/* Init tokenizer */
	285	eltok = tok_init(NULL);
	286	if (eltok == NULL) {
	287	log_warnx("lldpctl", "unable to initialize tokenizer");
	288	goto end;
	289	}
	290
fe80711e	291	skipeditline:
9a775667 VB	292	/* Make a connection */
	293	log_debug("lldpctl", "connect to lldpd");
	294	conn = lldpctl_new(NULL, NULL, NULL);
	295	if (conn == NULL)
	296	exit(EXIT_FAILURE);
	297
fe80711e	298	do {
9a775667	299	const char *line;
a8be34ba VB	300	const char **cargv;
a8be34ba VB	301	int count, n, cargc;
9a775667	302
a8be34ba	303	if (!is_lldpctl(NULL) && (optind >= argc)) {
fe80711e VB	304	/* Read a new line. */
	305	line = el_gets(el, &count);
	306	if (line == NULL) break;
	307
	308	/* Tokenize it */
	309	log_debug("lldpctl", "tokenize command line");
a8be34ba	310	n = tok_str(eltok, line, &cargc, &cargv);
fe80711e VB	311	switch (n) {
	312	case -1:
	313	log_warnx("lldpctl", "internal error while tokenizing");
	314	goto end;
	315	case 1:
	316	case 2:
	317	case 3:
	318	/* TODO: handle multiline statements */
	319	log_warnx("lldpctl", "unmatched quotes");
	320	tok_reset(eltok);
	321	continue;
	322	}
a8be34ba	323	if (cargc == 0) {
fe80711e VB	324	tok_reset(eltok);
	325	continue;
	326	}
	327	if (elhistory) history(elhistory, &elhistev, H_ENTER, line);
8729d69f	328	}
9a775667 VB	329
	330	/* Init output formatter */
	331	if (strcmp(fmt, "plain") == 0) w = txt_init(stdout);
	332	else if (strcmp(fmt, "keyvalue") == 0) w = kv_init(stdout);
	333	#ifdef USE_XML
	334	else if (strcmp(fmt, "xml") == 0) w = xml_init(stdout);
8b7150e4 VB	335	#endif
8b7150e4 VB	336	#ifdef USE_JSON
9a775667	337	else if (strcmp(fmt, "json") == 0) w = json_init(stdout);
4e90a9e0	338	#endif
9a775667	339	else w = txt_init(stdout);
4e90a9e0	340
fe80711e VB	341	if (is_lldpctl(NULL)) {
fe80711e VB	342	if (!interfaces) {
a8be34ba VB	343	cargv = (const char*[]){ "show", "neighbors", "details" };
a8be34ba VB	344	cargc = 3;
fe80711e	345	} else {
a8be34ba VB	346	cargv = (const char*[]){ "show", "neighbors", "ports", interfaces, "details" };
a8be34ba VB	347	cargc = 5;
fe80711e	348	}
a8be34ba VB	349	} else if (optind < argc) {
	350	cargv = (const char **)argv;
	351	cargv = &cargv[optind];
	352	cargc = argc - optind;
fe80711e VB	353	}
fe80711e VB	354
9a775667 VB	355	/* Execute command */
9a775667 VB	356	if (commands_execute(conn, w,
a8be34ba	357	root, cargc, cargv) != 0)
9a775667 VB	358	log_info("lldpctl", "an error occurred while executing last command");
9a775667 VB	359	w->finish(w);
fe80711e VB	360
	361	if (eltok) tok_reset(eltok);
	362	} while (!must_exit);
4b292b55	363
9a775667 VB	364	rc = EXIT_SUCCESS;
	365	end:
	366	if (conn) lldpctl_release(conn);
	367	if (eltok) tok_end(eltok);
	368	if (elhistory) history_end(elhistory);
	369	if (el) el_end(el);
	370	if (root) commands_free(root);
fe80711e	371	free(interfaces);
9a775667	372	return rc;
4b292b55	373	}