ctl_main.c

/*
  Command parsing taken from brctl utility.
  Display code from stp_cli.c in rstplib.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/errno.h>
#include <getopt.h>

#include <net/if.h>

/* For scanning through sysfs directories */
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <limits.h>

#include "ctl_socket_client.h"
#include "ctl_functions.h"

#ifndef False
# define False 0
# define True 1
#endif

#define STP_IN_get_error_explanation CTL_error_explanation

static void print_bridge_id(UID_BRIDGE_ID_T * bridge_id, unsigned char cr)
{
	printf("%04lX-%02x%02x%02x%02x%02x%02x",
	       (unsigned long)bridge_id->prio,
	       (unsigned char)bridge_id->addr[0],
	       (unsigned char)bridge_id->addr[1],
	       (unsigned char)bridge_id->addr[2],
	       (unsigned char)bridge_id->addr[3],
	       (unsigned char)bridge_id->addr[4],
	       (unsigned char)bridge_id->addr[5]);
	if (cr)
		printf("\n");
}

static char *stp_state2str(RSTP_PORT_STATE stp_port_state, int detail)
{
	if (detail) {
		switch (stp_port_state) {
		case UID_PORT_DISABLED:
			return "Disabled";
		case UID_PORT_DISCARDING:
			return "Discarding";
		case UID_PORT_LEARNING:
			return "Learning";
		case UID_PORT_FORWARDING:
			return "Forwarding";
		case UID_PORT_NON_STP:
			return "NoStp";
		default:
			return "Unknown";
		}
	}

	switch (stp_port_state) {
	case UID_PORT_DISABLED:
		return "Dis";
	case UID_PORT_DISCARDING:
		return "Blk";
	case UID_PORT_LEARNING:
		return "Lrn";
	case UID_PORT_FORWARDING:
		return "Fwd";
	case UID_PORT_NON_STP:
		return "Non";
	default:
		return "Unk";
	}
}

static void CLI_out_port_id(int port, unsigned char cr)
{
	static char ifname[IFNAMSIZ];
	if (if_indextoname(port, ifname))
		printf("%s", ifname);
	else
		printf("Ifindex %02d", port);
	if (cr)
		printf("\n");
}

int get_index_die(const char *ifname, const char *doc, int die)
{
	int r = if_nametoindex(ifname);
	if (r == 0) {
		fprintf(stderr,
			"Can't find index for %s %s. Not a valid interface.\n",
			doc, ifname);
		if (die)
			exit(1);
		return -1;
	}
	return r;
}

int get_index(const char *ifname, const char *doc)
{
	return get_index_die(ifname, doc, 1);
}

static int cmd_rstp(int argc, char *const *argv)
{
	int stp, r;
	int br_index = get_index(argv[1], "bridge");

	if (!strcmp(argv[2], "on") || !strcmp(argv[2], "yes")
	    || !strcmp(argv[2], "1"))
		stp = 1;
	else if (!strcmp(argv[2], "off") || !strcmp(argv[2], "no")
		 || !strcmp(argv[2], "0"))
		stp = 0;
	else {
		fprintf(stderr, "expect on/off for argument\n");
		return 1;
	}
	r = CTL_enable_bridge_rstp(br_index, stp);
	if (r) {
		fprintf(stderr, "Failed to enable/disable RSTP: %s\n",
			CTL_error_explanation(r));
		return -1;
	}
	return 0;
}

static int do_showbridge(const char *br_name)
{
	UID_STP_STATE_T uid_state;
	UID_STP_CFG_T uid_cfg;

	int br_index = get_index_die(br_name, "bridge", 0);
	if (br_index < 0)
		return -1;

	int r = CTL_get_bridge_state(br_index, &uid_cfg, &uid_state);
	if (r) {
		fprintf(stderr, "Failed to get bridge state: %s\n",
			CTL_error_explanation(r));
		return -1;
	}
#if 0
	printf("Interface:       %-7s (tag:%d)    State: ",
	       uid_state.vlan_name, (int)uid_state.vlan_id);
#else
	printf("Bridge:          %-7s               State:",
	       uid_state.vlan_name);
#endif
	switch (uid_state.stp_enabled) {
	case STP_ENABLED:
		printf("enabled\n");
		break;
	case STP_DISABLED:
		printf("disabled\n");
		break;
	default:
		printf("unknown\n");
		return 0;
	}

	printf("BridgeId:        ");
	print_bridge_id(&uid_state.bridge_id, 0);
	printf("     Bridge Proirity: %lu (0x%lX)\n",
	       (unsigned long)uid_state.bridge_id.prio,
	       (unsigned long)uid_state.bridge_id.prio);
	if (uid_cfg.force_version < 2)
		printf("Force Version:   stp\n");

	printf("Designated Root: ");
	print_bridge_id(&uid_state.designated_root, 1);
	if (uid_state.root_port) {
		printf("Root Port:       %04lx",
		       (unsigned long)uid_state.root_port);
		//        CLI_out_port_id (uid_state.root_port & 0xfff, False);
		//    printf("not implemented"); // XXX
		printf(", Root Cost:     %-lu\n",
		       (unsigned long)uid_state.root_path_cost);
	} else {
		printf("Root Port:       none\n");
	}

	printf("Topology Change Count: %lu\n",
	       uid_state.Topology_Change_Count);
	printf("Time Since Topology Change: %lu\n",
	       uid_state.Time_Since_Topology_Change);

	printf("Max Age:         %2d   Bridge Max Age:       %-2d\n",
	       (int)uid_state.max_age, (int)uid_cfg.max_age);
	printf("Hello Time:      %2d   Bridge Hello Time:    %-2d\n",
	       (int)uid_state.hello_time, (int)uid_cfg.hello_time);
	printf("Forward Delay:   %2d   Bridge Forward Delay: %-2d\n",
	       (int)uid_state.forward_delay, (int)uid_cfg.forward_delay);
	printf("Hold Time:       %2d\n", (int)uid_cfg.hold_time);

	return 0;
}

#define SYSFS_PATH_MAX 256
#define SYSFS_CLASS_NET "/sys/class/net"

static int isbridge(const struct dirent *entry)
{
	char path[SYSFS_PATH_MAX];
	struct stat st;

	snprintf(path, SYSFS_PATH_MAX, SYSFS_CLASS_NET "/%s/bridge",
		 entry->d_name);
	return stat(path, &st) == 0 && S_ISDIR(st.st_mode);
}

static int cmd_showbridge(int argc, char *const *argv)
{
	int i, count = 0;
	int r = 0;
	struct dirent **namelist;

	if (argc > 1) {
		count = argc - 1;
	} else {
		count =
		    scandir(SYSFS_CLASS_NET, &namelist, isbridge, alphasort);
		if (count < 0) {
			fprintf(stderr, "Error getting list of all bridges\n");
			return -1;
		}
	}

	for (i = 0; i < count; i++) {
		const char *name;
		if (argc > 1)
			name = argv[i + 1];
		else
			name = namelist[i]->d_name;

		int err = do_showbridge(name);
		if (err)
			r = err;
	}

	if (argc <= 1) {
		for (i = 0; i < count; i++)
			free(namelist[i]);
		free(namelist);
	}

	return r;
}

int detail = 0;

static int do_showport(int br_index, const char *port_name,
		       UID_STP_STATE_T * uid_state)
{
	UID_STP_PORT_STATE_T uid_port;
	UID_STP_PORT_CFG_T uid_cfg;
	int r = 0;
	int port_index = get_index_die(port_name, "port", 0);
	if (port_index < 0)
		return -1;

	memset(&uid_cfg, 0, sizeof(UID_STP_PORT_CFG_T));
	r = CTL_get_port_state(br_index, port_index, &uid_cfg, &uid_port);
	if (r) {
		fprintf(stderr, "Failed to get port state for port %d: %s\n",
			port_index, CTL_error_explanation(r));
		return -1;
	}

	if (detail) {
		printf("Stp Port ");
		CLI_out_port_id(port_index, False);
#if 0
		printf(": PortId: %04lx in vlan '%s' with tag %d:\n",
		       (unsigned long)uid_port.port_id, uid_state->vlan_name,
		       (int)uid_state->vlan_id);
#else
		printf(": PortId: %04lx in Bridge '%s':\n",
		       (unsigned long)uid_port.port_id, uid_state->vlan_name);
#endif
		printf("Priority:          %-d\n",
		       (int)(uid_port.port_id >> 8));
		printf("State:             %-16s",
		       stp_state2str(uid_port.state, 1));
		printf("       Uptime: %-9lu\n", uid_port.uptime);
		printf("PortPathCost:      admin: ");
		if (ADMIN_PORT_PATH_COST_AUTO == uid_cfg.admin_port_path_cost)
			printf("%-9s", "Auto");
		else
			printf("%-9lu", uid_cfg.admin_port_path_cost);
		printf("       oper: %-9lu\n", uid_port.oper_port_path_cost);

		printf("Point2Point:       admin: ");
		switch (uid_cfg.admin_point2point) {
			case P2P_FORCE_TRUE:
				printf("%-9s", "ForceYes");
				break;
			case P2P_FORCE_FALSE:
				printf("%-9s", "ForceNo");
				break;
			case P2P_AUTO:
				printf("%-9s", "Auto");
				break;
		}
		printf("       oper: %-9s\n",
		       uid_port.oper_point2point ? "Yes" : "No");
		printf("Edge:              admin: %-9s       oper: %-9s\n",
		       uid_cfg.admin_edge ? "Y" : "N",
		       uid_port.oper_edge ? "Y" : "N");
		printf("Partner:                                  oper: %-9s\n",
		       uid_port.oper_stp_neigb ? "Slow" : "Rapid");

		if (' ' != uid_port.role) {
			if ('-' != uid_port.role) {
				printf("PathCost:          %-lu\n",
				       (unsigned long)(uid_port.path_cost));
				printf("Designated Root:   ");
				print_bridge_id(&uid_port.designated_root, 1);
				printf("Designated Cost:   %-ld\n",
				       (unsigned long)uid_port.designated_cost);
				printf("Designated Bridge: ");
				print_bridge_id(&uid_port.designated_bridge, 1);
				printf("Designated Port:   %-4lx\n\r",
				       (unsigned long)uid_port.designated_port);
			}
			printf("Role:              ");
			switch (uid_port.role) {
				case 'A':
					printf("Alternate\n");
					break;
				case 'B':
					printf("Backup\n");
					break;
				case 'R':
					printf("Root\n");
					break;
				case 'D':
					printf("Designated\n");
					break;
				case '-':
					printf("NonStp\n");
					break;
				default:
					printf("Unknown(%c)\n", uid_port.role);
					break;
			}

			if ('R' == uid_port.role || 'D' == uid_port.role) {
				/* printf("Tc:                %c  ", uid_port.tc ? 'Y' : 'n'); */
				printf("TcAck:             %c  ",
				       uid_port.top_change_ack ? 'Y' : 'N');
				printf("TcWhile:       %3d\n",
				       (int)uid_port.tcWhile);
			}
		}

		if (UID_PORT_DISABLED == uid_port.state || '-' == uid_port.role) {
#if 0
			printf("helloWhen:       %3d  ",
			       (int)uid_port.helloWhen);
			printf("edgeDelayWhile:      %3d\n", (int)uid_port.edgeDelayWhile);
			printf("fdWhile:         %3d\n", (int)uid_port.fdWhile);
#endif
		} else if ('-' != uid_port.role) {
			printf("fdWhile:         %3d  ", (int)uid_port.fdWhile);
			printf("rcvdInfoWhile: %3d\n",
			       (int)uid_port.rcvdInfoWhile);
			printf("rbWhile:         %3d  ", (int)uid_port.rbWhile);
			printf("rrWhile:       %3d\n", (int)uid_port.rrWhile);
#if 0
			printf("mdelayWhile:     %3d  ",
			       (int)uid_port.mdelayWhile);
			printf("edgeDelayWhile:      %3d\n", (int)uid_port.edgeDelayWhile);
			printf("helloWhen:       %3d  ",
			       (int)uid_port.helloWhen);
			printf("txCount:       %3d\n", (int)uid_port.txCount);
#endif
		}

		printf("RSTP BPDU rx:      %lu\n",
		       (unsigned long)uid_port.rx_rstp_bpdu_cnt);
		printf("CONFIG BPDU rx:    %lu\n",
		       (unsigned long)uid_port.rx_cfg_bpdu_cnt);
		printf("TCN BPDU rx:       %lu\n",
		       (unsigned long)uid_port.rx_tcn_bpdu_cnt);
	} else {
		printf("%c%c%c  ",
		       (uid_port.oper_point2point) ? ' ' : '*',
		       (uid_port.oper_edge) ? 'E' : ' ',
		       (uid_port.oper_stp_neigb) ? 's' : ' ');
		CLI_out_port_id(port_index, False);
		printf(" %04lx %3s ", (unsigned long)uid_port.port_id,
		       stp_state2str(uid_port.state, 0));
		printf(" ");
		print_bridge_id(&uid_port.designated_root, 0);
		printf(" ");
		print_bridge_id(&uid_port.designated_bridge, 0);
		printf(" %4lx %c", (unsigned long)uid_port.designated_port,
		       uid_port.role);
		printf("\n");
	}
	return 0;
}

static int not_dot_dotdot(const struct dirent *entry)
{
	const char *n = entry->d_name;

	return !(n[0] == '.' && (n[1] == 0 || (n[1] == '.' && n[2] == 0)));
}

static int cmd_showport(int argc, char *const *argv)
{
	UID_STP_STATE_T uid_state;
	UID_STP_CFG_T uid_br_cfg;
	int r = 0;

	int br_index = get_index(argv[1], "bridge");

	r = CTL_get_bridge_state(br_index, &uid_br_cfg, &uid_state);
	if (r) {
		fprintf(stderr, "Failed to get bridge state: %s\n",
			CTL_error_explanation(r));
		return -1;
	}

	int i, count = 0;
	struct dirent **namelist;

	if (argc > 2) {
		count = argc - 2;
	} else {
		char buf[SYSFS_PATH_MAX];
		snprintf(buf, sizeof(buf), SYSFS_CLASS_NET "/%s/brif", argv[1]);
		count = scandir(buf, &namelist, not_dot_dotdot, alphasort);
		if (count < 0) {
			fprintf(stderr,
				"Error getting list of all ports of bridge %s\n",
				argv[1]);
			return -1;
		}
	}

	for (i = 0; i < count; i++) {
		const char *name;
		if (argc > 2)
			name = argv[i + 2];
		else
			name = namelist[i]->d_name;

		int err = do_showport(br_index, name, &uid_state);
		if (err)
			r = err;
	}

	if (argc <= 2) {
		for (i = 0; i < count; i++)
			free(namelist[i]);
		free(namelist);
	}

	return r;
}

static int cmd_showportdetail(int argc, char *const *argv)
{
	detail = 1;
	return cmd_showport(argc, argv);
}

unsigned int getuint(const char *s)
{
	char *end;
	long l;
	l = strtoul(s, &end, 0);
	if (*s == 0 || *end != 0 || l > INT_MAX) {
		fprintf(stderr, "Invalid unsigned int arg %s\n", s);
		exit(1);
	}
	return l;
}

int getenum(const char *s, const char *opt[])
{
	int i;
	for (i = 0; opt[i] != NULL; i++)
		if (strcmp(s, opt[i]) == 0)
			return i;

	fprintf(stderr, "Invalid argument %s: expecting one of ", s);
	for (i = 0; opt[i] != NULL; i++)
		fprintf(stderr, "%s%s", opt[i], (opt[i + 1] ? ", " : "\n"));

	exit(1);
}

int getyesno(const char *s, const char *yes, const char *no)
{
	/* Reverse yes and no so error message looks more normal */
	const char *opt[] = { yes, no, NULL };
	return 1 - getenum(s, opt);
}

static int set_bridge_cfg_value(int br_index, unsigned long value,
				unsigned long val_mask)
{
	UID_STP_CFG_T uid_cfg;
	char *val_name;
	int rc;

	uid_cfg.field_mask = val_mask;
	switch (val_mask) {
	case BR_CFG_STATE:
		uid_cfg.stp_enabled = value;
		val_name = "state";
		break;
	case BR_CFG_PRIO:
		uid_cfg.bridge_priority = value;
		val_name = "priority";
		break;
	case BR_CFG_AGE:
		uid_cfg.max_age = value;
		val_name = "max_age";
		break;
	case BR_CFG_HELLO:
		uid_cfg.hello_time = value;
		val_name = "hello_time";
		break;
	case BR_CFG_DELAY:
		uid_cfg.forward_delay = value;
		val_name = "forward_delay";
		break;
	case BR_CFG_FORCE_VER:
		uid_cfg.force_version = value;
		val_name = "force_version";
		break;
	case BR_CFG_AGE_MODE:
	case BR_CFG_AGE_TIME:
	default:
		printf("Invalid value mask 0X%lx\n", val_mask);
		return -1;
		break;
	}

	rc = CTL_set_bridge_config(br_index, &uid_cfg);

	if (0 != rc) {
		printf("Can't change rstp bridge %s:%s\n", val_name,
		       STP_IN_get_error_explanation(rc));
		return -1;
	}
	return 0;
}

static int cmd_setbridgestate(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	return set_bridge_cfg_value(br_index,
				    getyesno(argv[2], "on", "off"),
				    BR_CFG_STATE);
}

static int cmd_setbridgeprio(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	return set_bridge_cfg_value(br_index, getuint(argv[2]), BR_CFG_PRIO);
}

static int cmd_setbridgemaxage(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	return set_bridge_cfg_value(br_index, getuint(argv[2]), BR_CFG_AGE);
}

static int cmd_setbridgehello(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	return set_bridge_cfg_value(br_index, getuint(argv[2]), BR_CFG_HELLO);
}

static int cmd_setbridgefdelay(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	return set_bridge_cfg_value(br_index, getuint(argv[2]), BR_CFG_DELAY);
}

static int cmd_setbridgeforcevers(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	return set_bridge_cfg_value(br_index,
				    2 * getyesno(argv[2], "normal", "slow"),
				    BR_CFG_FORCE_VER);
}

static int
set_port_cfg_value(int br_index, int port_index,
		   unsigned long value, unsigned long val_mask)
{
	UID_STP_PORT_CFG_T uid_cfg;
	int rc;
	char *val_name;

	BitmapClear(&uid_cfg.port_bmp);
	uid_cfg.field_mask = val_mask;
	switch (val_mask) {
	case PT_CFG_MCHECK:
		val_name = "mcheck";
		break;
	case PT_CFG_COST:
		uid_cfg.admin_port_path_cost = value;
		val_name = "path cost";
		break;
	case PT_CFG_PRIO:
		uid_cfg.port_priority = value;
		val_name = "priority";
		break;
	case PT_CFG_P2P:
		uid_cfg.admin_point2point = (ADMIN_P2P_T) value;
		val_name = "p2p flag";
		break;
	case PT_CFG_EDGE:
		uid_cfg.admin_edge = value;
		val_name = "adminEdge";
		break;
	case PT_CFG_NON_STP:
		uid_cfg.admin_non_stp = value;
		val_name = "adminNonStp";
		break;
#ifdef STP_DBG
	case PT_CFG_DBG_SKIP_TX:
		uid_cfg.skip_tx = value;
		val_name = "skip tx";
		break;
	case PT_CFG_DBG_SKIP_RX:
		uid_cfg.skip_rx = value;
		val_name = "skip rx";
		break;
#endif
	case PT_CFG_STATE:
	default:
		printf("Invalid value mask 0X%lx\n", val_mask);
		return -1;
	}

	rc = CTL_set_port_config(br_index, port_index, &uid_cfg);

	if (0 != rc) {
		printf("can't change rstp port[s] %s: %s\n",
		       val_name, STP_IN_get_error_explanation(rc));
		return -1;
	}
	return 0;
}

static int cmd_setportprio(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	int port_index = get_index(argv[2], "port");
	return set_port_cfg_value(br_index, port_index,
				  getuint(argv[3]), PT_CFG_PRIO);
}

static int cmd_setportpathcost(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	int port_index = get_index(argv[2], "port");
	return set_port_cfg_value(br_index, port_index,
				  getuint(argv[3]), PT_CFG_COST);
}

static int cmd_setportedge(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	int port_index = get_index(argv[2], "port");
	return set_port_cfg_value(br_index, port_index,
				  getyesno(argv[3], "yes", "no"), PT_CFG_EDGE);
}

static int cmd_setportnonstp(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	int port_index = get_index(argv[2], "port");
	return set_port_cfg_value(br_index, port_index,
				  getyesno(argv[3], "yes", "no"),
				  PT_CFG_NON_STP);
}

static int cmd_setportp2p(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	int port_index = get_index(argv[2], "port");
	const char *opts[] = { "yes", "no", "auto", NULL };
	int vals[] = { P2P_FORCE_TRUE, P2P_FORCE_FALSE, P2P_AUTO };

	return set_port_cfg_value(br_index, port_index,
				  vals[getenum(argv[3], opts)], PT_CFG_P2P);
}

static int cmd_portmcheck(int argc, char *const *argv)
{

	int br_index = get_index(argv[1], "bridge");
	int port_index = get_index(argv[2], "port");
	return set_port_cfg_value(br_index, port_index, 0, PT_CFG_MCHECK);
}

static int cmd_debuglevel(int argc, char *const *argv)
{
	return CTL_set_debug_level(getuint(argv[1]));
}

struct command {
	int nargs;
	int optargs;
	const char *name;
	int (*func) (int argc, char *const *argv);
	const char *help;
};

static const struct command commands[] = {
	{0, 32, "showbridge", cmd_showbridge,
	 "[<bridge> ... ]\t\tshow bridge state"},
	{1, 32, "showport", cmd_showport,
	 "<bridge> [<port> ... ]\tshow port state"},
	{1, 32, "showportdetail", cmd_showportdetail,
	 "<bridge> [<port> ... ]\tshow port state (detail)"},
	{2, 0, "rstp", cmd_rstp,
	 "<bridge> {on|off}\tenable/disable rstpd control"},
	{2, 0, "setbridgestate", cmd_setbridgestate,
	 "<bridge> {on|off}\tstart/stop rstp (when enabled)"},
	{2, 0, "setbridgeprio", cmd_setbridgeprio,
	 "<bridge> <priority>\tset bridge priority (0-61440)"},
	{2, 0, "sethello", cmd_setbridgehello,
	 "<bridge> <hellotime>\tset bridge hello time (1-10)"},
	{2, 0, "setmaxage", cmd_setbridgemaxage,
	 "<bridge> <maxage>\tset bridge max age (6-40)"},
	{2, 0, "setfdelay", cmd_setbridgefdelay,
	 "<bridge> <fwd_delay>\tset bridge forward delay (4-30)"},
	{2, 0, "setforcevers", cmd_setbridgeforcevers,
	 "<bridge> {normal|slow}\tnormal RSTP or force to STP"},
	{3, 0, "setportprio", cmd_setportprio,
	 "<bridge> <port> <priority>\tset port priority (0-240)"},
	{3, 0, "setportpathcost", cmd_setportpathcost,
	 "<bridge> <port> <cost>\tset port path cost"},
	{3, 0, "setportedge", cmd_setportedge,
	 "<bridge> <port> {yes|no}\tconfigure if it is an edge port"},
	{3, 0, "setportnonstp", cmd_setportnonstp,
	 "<bridge> <port> {yes|no}\tdisable STP for the port"},
	{3, 0, "setportp2p", cmd_setportp2p,
	 "<bridge> <port> {yes|no|auto}\tset whether p2p connection"},
	{2, 0, "portmcheck", cmd_portmcheck,
	 "<bridge> <port>\ttry to get back from STP to RSTP mode"},
	{1, 0, "debuglevel", cmd_debuglevel, "<level>\t\tLevel of verbosity"},
};

const struct command *command_lookup(const char *cmd)
{
	int i;

	for (i = 0; i < sizeof(commands) / sizeof(commands[0]); i++) {
		if (!strcmp(cmd, commands[i].name))
			return &commands[i];
	}

	return NULL;
}

void command_helpall(void)
{
	int i;

	for (i = 0; i < sizeof(commands) / sizeof(commands[0]); i++) {
		printf("\t%-10s\t%s\n", commands[i].name, commands[i].help);
	}
}

static void help()
{
	printf("Usage: rstpctl [commands]\n");
	printf("commands:\n");
	command_helpall();
}

#define PACKAGE_VERSION2(v, b) "rstp, " #v "-" #b
#define PACKAGE_VERSION(v, b) PACKAGE_VERSION2(v, b)

int main(int argc, char *const *argv)
{
	const struct command *cmd;
	int f;
	static const struct option options[] = {
		{.name = "help",.val = 'h'},
		{.name = "version",.val = 'V'},
		{0}
	};

	while ((f = getopt_long(argc, argv, "Vh", options, NULL)) != EOF)
		switch (f) {
		case 'h':
			help();
			return 0;
		case 'V':
			printf("%s\n", PACKAGE_VERSION(VERSION, BUILD));
			return 0;
		default:
			fprintf(stderr, "Unknown option '%c'\n", f);
			goto help;
		}

	if (argc == optind)
		goto help;

	if (ctl_client_init()) {
		fprintf(stderr, "can't setup control connection\n");
		return 1;
	}

	argc -= optind;
	argv += optind;
	if ((cmd = command_lookup(argv[0])) == NULL) {
		fprintf(stderr, "never heard of command [%s]\n", argv[0]);
		goto help;
	}

	if (argc < cmd->nargs + 1 || argc > cmd->nargs + cmd->optargs + 1) {
		printf("Incorrect number of arguments for command\n");
		printf("Usage: rstpctl %s %s\n", cmd->name, cmd->help);
		return 1;
	}

	return cmd->func(argc, argv);

      help:
	help();
	return 1;
}