/* -*- 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 <limits.h>

/**

 * Show neighbors.

 *

 * The environment will contain the following keys:

 *  - C{ports} list of ports we want to restrict showing.

 *  - C{hidden} if we should show hidden ports.

 *  - C{summary} if we want to show only a summary

 *  - C{detailed} for a detailed overview

 */

static int

cmd_show_neighbors(struct lldpctl_conn_t *conn, struct writer *w,

    struct cmd_env *env, void *arg)

{

	log_debug("lldpctl", "show neighbors data (%s) %s hidden neighbors",

	    cmdenv_get(env, "summary")?"summary":

	    cmdenv_get(env, "detailed")?"detailed":

	    "normal", cmdenv_get(env, "hidden")?"with":"without");

	if (cmdenv_get(env, "ports"))

		log_debug("lldpctl", "restrict to the following ports: %s",

		    cmdenv_get(env, "ports"));

	display_interfaces(conn, w, env, !!cmdenv_get(env, "hidden"),

	    cmdenv_get(env, "summary")?DISPLAY_BRIEF:

	    cmdenv_get(env, "detailed")?DISPLAY_DETAILS:

	    DISPLAY_NORMAL);

	return 1;

}

/**

 * Show interfaces.

 *

 * The environment will contain the following keys:

 *  - C{ports} list of ports we want to restrict showing.

 *  - C{hidden} if we should show hidden ports.

 *  - C{summary} if we want to show only a summary

 *  - C{detailed} for a detailed overview

 */

static int

cmd_show_interfaces(struct lldpctl_conn_t *conn, struct writer *w,

    struct cmd_env *env, void *arg)

{

	log_debug("lldpctl", "show interfaces data (%s) %s hidden interfaces",

	    cmdenv_get(env, "summary")?"summary":

	    cmdenv_get(env, "detailed")?"detailed":

	    "normal", cmdenv_get(env, "hidden")?"with":"without");

	if (cmdenv_get(env, "ports"))

		log_debug("lldpctl", "restrict to the following ports: %s",

		    cmdenv_get(env, "ports"));

	display_local_interfaces(conn, w, env, !!cmdenv_get(env, "hidden"),

	    cmdenv_get(env, "summary")?DISPLAY_BRIEF:

	    cmdenv_get(env, "detailed")?DISPLAY_DETAILS:

	    DISPLAY_NORMAL);

	return 1;

}

/**

 * Show chassis.

 *

 * The environment will contain the following keys:

 *  - C{summary} if we want to show only a summary

 *  - C{detailed} for a detailed overview

 */

static int

cmd_show_chassis(struct lldpctl_conn_t *conn, struct writer *w,

    struct cmd_env *env, void *arg)

{

	log_debug("lldpctl", "show chassis data (%s)",

	    cmdenv_get(env, "summary")?"summary":

	    cmdenv_get(env, "detailed")?"detailed":

	    "normal");

	display_local_chassis(conn, w, env,

	    cmdenv_get(env, "summary")?DISPLAY_BRIEF:

	    cmdenv_get(env, "detailed")?DISPLAY_DETAILS:

	    DISPLAY_NORMAL);

	return 1;

}

/**

 * Show stats.

 *

 * The environment will contain the following keys:

 *  - C{ports} list of ports we want to restrict showing.

 *  - C{summary} summary of stats

 */

static int

cmd_show_interface_stats(struct lldpctl_conn_t *conn, struct writer *w,

    struct cmd_env *env, void *arg)

{

	log_debug("lldpctl", "show stats data");

	if (cmdenv_get(env, "ports"))

		log_debug("lldpctl", "restrict to the following ports: %s",

		    cmdenv_get(env, "ports"));

	if (cmdenv_get(env, "summary"))

		log_debug("lldpctl", "show summary of stats across ports");

	display_interfaces_stats(conn, w, env);

	return 1;

}

static int

cmd_check_no_detailed_nor_summary(struct cmd_env *env, void *arg)

{

	if (cmdenv_get(env, "detailed")) return 0;

	if (cmdenv_get(env, "summary")) return 0;

	return 1;

}

/**

 * Show running configuration.

 */

static int

cmd_show_configuration(struct lldpctl_conn_t *conn, struct writer *w,

    struct cmd_env *env, void *arg)

{

	log_debug("lldpctl", "show running configuration");

	display_configuration(conn, w);

	return 1;

}

struct watcharg {

	struct cmd_env *env;

	struct writer *w;

	size_t nb;

};

/**

 * Callback for the next function to display a new neighbor.

 */

static void

watchcb(lldpctl_conn_t *conn,

    lldpctl_change_t type,

    lldpctl_atom_t *interface,

    lldpctl_atom_t *neighbor,

    void *data)

{

	struct watcharg *wa = data;

	struct cmd_env *env = wa->env;

	struct writer *w = wa->w;

	const char *interfaces = cmdenv_get(env, "ports");

	const char *proto_str;

	int protocol = LLDPD_MODE_MAX;

	if (interfaces && !contains(interfaces, lldpctl_atom_get_str(interface,

		    lldpctl_k_interface_name)))

		return;

	/* user might have specified protocol to filter display results */

	proto_str = cmdenv_get(env, "protocol");

	if (proto_str) {

		log_debug("display", "filter protocol: %s ", proto_str);

		protocol = 0;	/* unsupported */

		for (lldpctl_map_t *protocol_map =

			 lldpctl_key_get_map(lldpctl_k_port_protocol);

		     protocol_map->string;

		     protocol_map++) {

			if (!strcasecmp(proto_str, protocol_map->string)) {

				protocol = protocol_map->value;

				break;

			}

		}

	}

	switch (type) {

	case lldpctl_c_deleted:

		tag_start(w, "lldp-deleted", "LLDP neighbor deleted");

		break;

	case lldpctl_c_updated:

		tag_start(w, "lldp-updated", "LLDP neighbor updated");

		break;

	case lldpctl_c_added:

		tag_start(w, "lldp-added", "LLDP neighbor added");

		break;

	default: return;

	}

	display_interface(conn, w, 1, interface, neighbor,

	    cmdenv_get(env, "summary")?DISPLAY_BRIEF:

	    cmdenv_get(env, "detailed")?DISPLAY_DETAILS:

	    DISPLAY_NORMAL, protocol);

	tag_end(w);

	wa->nb++;

}

/**

 * Watch for neighbor changes.

 */

static int

cmd_watch_neighbors(struct lldpctl_conn_t *conn, struct writer *w,

    struct cmd_env *env, void *arg)

{

	struct watcharg wa = {

		.env = env,

		.w = w,

		.nb = 0

	};

	const char *limit_str = cmdenv_get(env, "limit");

	size_t limit = 0;

	if (limit_str) {

		const char *errstr;

		limit = strtonum(limit_str, 1, LLONG_MAX, &errstr);

		if (errstr != NULL) {

			log_warnx("lldpctl", "specified limit (%s) is %s and ignored",

			    limit_str, errstr);

		}

	}

	log_debug("lldpctl", "watch for neighbor changes");

	if (lldpctl_watch_callback(conn, watchcb, &wa) < 0) {

		log_warnx("lldpctl", "unable to watch for neighbors. %s",

		    lldpctl_last_strerror(conn));

		return 0;

	}

	while (1) {

		if (lldpctl_watch(conn) < 0) {

			log_warnx("lldpctl", "unable to watch for neighbors. %s",

			    lldpctl_last_strerror(conn));

			return 0;

		}

		if (limit > 0 && wa.nb >= limit)

			return 1;

	}

	return 0;

}

/**

 * Register common subcommands for `watch` and `show neighbors` and `show chassis'

 */

void

register_common_commands(struct cmd_node *root, int neighbor)

{

	/* With more details */

	commands_new(root,

	    "details",

	    "With more details",

	    cmd_check_no_detailed_nor_summary, cmd_store_env_and_pop, "detailed");

	/* With less details */

	commands_new(root,

	    "summary",

	    "With less details",

	    cmd_check_no_detailed_nor_summary, cmd_store_env_and_pop, "summary");

	if (!neighbor) return;

	/* With hidden neighbors */

	commands_new(root,

	    "hidden",

	    "Include hidden neighbors",

	    cmd_check_no_env, cmd_store_env_and_pop, "hidden");

	/* Some specific port */

	cmd_restrict_ports(root);

	/* Specific protocol */

	cmd_restrict_protocol(root);

}

/**

 * Register sub command summary

 */

void

register_summary_command(struct cmd_node *root)

{

	commands_new(root,

			"summary",

			"With less details",

			cmd_check_no_detailed_nor_summary, cmd_store_env_and_pop, "summary");

}

/**

 * Register subcommands to `show`

 *

 * @param root Root node

 */

void

register_commands_show(struct cmd_node *root)

{

	struct cmd_node *show = commands_new(

		root,

		"show",

		"Show running system information",

		NULL, NULL, NULL);

	struct cmd_node *neighbors = commands_new(

		show,

		"neighbors",

		"Show neighbors data",

		NULL, NULL, NULL);

	struct cmd_node *interfaces = commands_new(

		show,

		"interfaces",

		"Show interfaces data",

		NULL, NULL, NULL);

	struct cmd_node *chassis = commands_new(

		show,

		"chassis",

		"Show local chassis data",

		NULL, NULL, NULL);

	struct cmd_node *stats = commands_new(

		show,

		"statistics",

		"Show statistics",

		NULL, NULL, NULL);

	/* Neighbors data */

	commands_new(neighbors,

	    NEWLINE,

	    "Show neighbors data",

	    NULL, cmd_show_neighbors, NULL);

	register_common_commands(neighbors, 1);

	/* Interfaces data */

	commands_new(interfaces,

	    NEWLINE,

	    "Show interfaces data",

	    NULL, cmd_show_interfaces, NULL);

	cmd_restrict_ports(interfaces);

	register_common_commands(interfaces, 0);

	/* Chassis data */

	commands_new(chassis,

	    NEWLINE,

	    "Show local chassis data",

	    NULL, cmd_show_chassis, NULL);

	register_common_commands(chassis, 0);

	/* Stats data */

	commands_new(stats,

	    NEWLINE,

	    "Show stats data",

	    NULL, cmd_show_interface_stats, NULL);

	cmd_restrict_ports(stats);

	register_summary_command(stats);

	/* Register "show configuration" and "show running-configuration" */

	commands_new(

		commands_new(show,

		    "configuration",

		    "Show running configuration",

		    NULL, NULL, NULL),

		NEWLINE,

		"Show running configuration",

		NULL, cmd_show_configuration, NULL);

	commands_new(

		commands_new(show,

		    "running-configuration",

		    "Show running configuration",

		    NULL, NULL, NULL),

		NEWLINE,

		"Show running configuration",

		NULL, cmd_show_configuration, NULL);

}

/**

 * Register subcommands to `watch`

 *

 * @param root Root node

 */

void

register_commands_watch(struct cmd_node *root)

{

	struct cmd_node *watch = commands_new(

		root,

		"watch",

		"Monitor neighbor changes",

		NULL, NULL, NULL);

	commands_new(watch,

	    NEWLINE,

	    "Monitor neighbors change",

	    NULL, cmd_watch_neighbors, NULL);

	commands_new(

		commands_new(watch,

		    "limit",

		    "Don't show more than X events",

		    cmd_check_no_env, NULL, "limit"),

		NULL,

		"Stop after getting X events",

		NULL, cmd_store_env_value_and_pop2, "limit");

	register_common_commands(watch, 1);

}