Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.sbin/eigrpctl/parser.c	Lines:	0	139	0.0 %
Date:	2017-11-07	Branches:	0	117	0.0 %


/*	$OpenBSD: parser.c,v 1.4 2016/01/15 12:57:49 renato Exp $ */

/*
 * Copyright (c) 2015 Renato Westphal <renato@openbsd.org>
 * Copyright (c) 2004 Esben Norby <norby@openbsd.org>
 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
 *
 * Permission to use, copy, modify, and 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 <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <err.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <netdb.h>

#include "eigrpd.h"

#include "parser.h"

enum token_type {
	NOTOKEN,
	ENDTOKEN,
	KEYWORD,
	FAMILY,
	ASNUM,
	ADDRESS,
	FLAG,
	PREFIX,
	IFNAME
};

struct token {
	enum token_type		 type;
	const char		*keyword;
	int			 value;
	const struct token	*next;
};

static const struct token t_main[];
static const struct token t_fib[];
static const struct token t_show[];
static const struct token t_show_iface[];
static const struct token t_show_iface_af[];
static const struct token t_show_iface_as[];
static const struct token t_show_nbr[];
static const struct token t_show_nbr_af[];
static const struct token t_show_nbr_as[];
static const struct token t_show_topology[];
static const struct token t_show_topology_af[];
static const struct token t_show_topology_as[];
static const struct token t_show_fib[];
static const struct token t_show_fib_af[];
static const struct token t_show_stats[];
static const struct token t_show_stats_af[];
static const struct token t_show_stats_as[];
static const struct token t_log[];
static const struct token t_clear[];
static const struct token t_clear_nbr[];
static const struct token t_clear_nbr_af[];
static const struct token t_clear_nbr_as[];

static const struct token t_main[] = {
	{KEYWORD,	"reload",	RELOAD,		NULL},
	{KEYWORD,	"fib",		FIB,		t_fib},
	{KEYWORD,	"show",		SHOW,		t_show},
	{KEYWORD,	"clear",	NONE,		t_clear},
	{KEYWORD,	"log",		NONE,		t_log},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_fib[] = {
	{ KEYWORD,	"couple",	FIB_COUPLE,	NULL},
	{ KEYWORD,	"decouple",	FIB_DECOUPLE,	NULL},
	{ ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show[] = {
	{NOTOKEN,	"",		NONE,		NULL},
	{KEYWORD,	"interfaces",	SHOW_IFACE,	t_show_iface},
	{KEYWORD,	"neighbor",	SHOW_NBR,	t_show_nbr},
	{KEYWORD,	"topology",	SHOW_TOPOLOGY,	t_show_topology},
	{KEYWORD,	"fib",		SHOW_FIB,	t_show_fib},
	{KEYWORD,	"traffic",	SHOW_STATS,	t_show_stats},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show_iface[] = {
	{NOTOKEN,	"",		NONE,			NULL},
	{KEYWORD,	"family",	NONE,			t_show_iface_af},
	{KEYWORD,	"as",		NONE,			t_show_iface_as},
	{KEYWORD,	"detail",	SHOW_IFACE_DTAIL,	NULL},
	{IFNAME,	"",		SHOW_IFACE_DTAIL,	NULL},
	{ENDTOKEN,	"",		NONE,			NULL}
};

static const struct token t_show_iface_af[] = {
	{FAMILY,	"",		NONE,		t_show_iface},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show_iface_as[] = {
	{ASNUM,		"",		NONE,		t_show_iface},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show_nbr[] = {
	{NOTOKEN,	"",		NONE,		NULL},
	{KEYWORD,	"family",	NONE,		t_show_nbr_af},
	{KEYWORD,	"as",		NONE,		t_show_nbr_as},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show_nbr_af[] = {
	{FAMILY,	"",		NONE,		t_show_nbr},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show_nbr_as[] = {
	{ASNUM,		"",		NONE,		t_show_nbr},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show_topology[] = {
	{NOTOKEN,	"",		NONE,		NULL},
	{KEYWORD,	"family",	NONE,		t_show_topology_af},
	{KEYWORD,	"as",		NONE,		t_show_topology_as},
	{PREFIX,	"",		NONE,		NULL},
	{FLAG,		"active",	F_CTL_ACTIVE,	NULL},
	{FLAG,		"all-links",	F_CTL_ALLLINKS,	NULL},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show_topology_af[] = {
	{FAMILY,	"",		NONE,		t_show_topology},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show_topology_as[] = {
	{ASNUM,		"",		NONE,		t_show_topology},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show_fib[] = {
	{NOTOKEN,	"",		NONE,			NULL},
	{KEYWORD,	"family",	NONE,			t_show_fib_af},
	{KEYWORD,	"interface",	SHOW_FIB_IFACE,		t_show_iface},
	{FLAG,		"connected",	F_CONNECTED,		t_show_fib},
	{FLAG,		"static",	F_STATIC,		t_show_fib},
	{FLAG,		"eigrp",	F_EIGRPD_INSERTED,	t_show_fib},
	{ENDTOKEN,	"",		NONE,			NULL}
};

static const struct token t_show_fib_af[] = {
	{FAMILY,	"",		NONE,		t_show_fib},
	{ENDTOKEN,	"",		NONE,		NULL}
};


static const struct token t_show_stats[] = {
	{NOTOKEN,	"",		NONE,		NULL},
	{KEYWORD,	"family",	NONE,		t_show_stats_af},
	{KEYWORD,	"as",		NONE,		t_show_stats_as},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show_stats_af[] = {
	{FAMILY,	"",		NONE,		t_show_stats},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_show_stats_as[] = {
	{ASNUM,		"",		NONE,		t_show_stats},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_clear[] = {
	{KEYWORD,	"neighbors",	CLEAR_NBR,	t_clear_nbr},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_clear_nbr[] = {
	{NOTOKEN,	"",		NONE,		NULL},
	{KEYWORD,	"as",		NONE,		t_clear_nbr_as},
	{KEYWORD,	"family",	NONE,		t_clear_nbr_af},
	{ADDRESS,	"",		NONE,		NULL},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_clear_nbr_af[] = {
	{FAMILY,	"",		NONE,		t_clear_nbr},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_clear_nbr_as[] = {
	{ASNUM,		"",		NONE,		t_clear_nbr},
	{ENDTOKEN,	"",		NONE,		NULL}
};

static const struct token t_log[] = {
	{KEYWORD,	"verbose",	LOG_VERBOSE,		NULL},
	{KEYWORD,	"brief",	LOG_BRIEF,		NULL},
	{ENDTOKEN,	"",		NONE,			NULL}
};

static const struct token *match_token(const char *, const struct token *,
    struct parse_result *);
static void show_valid_args(const struct token *);

struct parse_result *
parse(int argc, char *argv[])
{
	static struct parse_result	res;
	const struct token	*table = t_main;
	const struct token	*match;

	memset(&res, 0, sizeof(res));

	while (argc >= 0) {
		if ((match = match_token(argv[0], table, &res)) == NULL) {
			fprintf(stderr, "valid commands/args:\n");
			show_valid_args(table);
			return (NULL);
		}

		argc--;
		argv++;

		if (match->type == NOTOKEN || match->next == NULL)
			break;

		table = match->next;
	}

	if (argc > 0) {
		fprintf(stderr, "superfluous argument: %s\n", argv[0]);
		return (NULL);
	}

	return (&res);
}

static const struct token *
match_token(const char *word, const struct token *table,
    struct parse_result *res)
{
	unsigned int		 i, match;
	const struct token	*t = NULL;

	match = 0;

	for (i = 0; table[i].type != ENDTOKEN; i++) {
		switch (table[i].type) {
		case NOTOKEN:
			if (word == NULL || strlen(word) == 0) {
				match++;
				t = &table[i];
			}
			break;
		case KEYWORD:
			if (word != NULL && strncmp(word, table[i].keyword,
			    strlen(word)) == 0) {
				match++;
				t = &table[i];
				if (t->value)
					res->action = t->value;
			}
			break;
		case FLAG:
			if (word != NULL && strncmp(word, table[i].keyword,
			    strlen(word)) == 0) {
				match++;
				t = &table[i];
				res->flags |= t->value;
			}
			break;
		case FAMILY:
			if (word == NULL)
				break;
			if (!strcmp(word, "inet") ||
			    !strcasecmp(word, "IPv4")) {
				match++;
				t = &table[i];
				res->family = AF_INET;
			}
			if (!strcmp(word, "inet6") ||
			    !strcasecmp(word, "IPv6")) {
				match++;
				t = &table[i];
				res->family = AF_INET6;
			}
			break;
		case ASNUM:
			if (parse_asnum(word, &res->as)) {
				match++;
				t = &table[i];
			}
			break;
		case ADDRESS:
			if (parse_addr(word, &res->family, &res->addr)) {
				match++;
				t = &table[i];
				if (t->value)
					res->action = t->value;
			}
			break;
		case PREFIX:
			if (parse_prefix(word, &res->family, &res->addr,
			    &res->prefixlen)) {
				match++;
				t = &table[i];
				if (t->value)
					res->action = t->value;
			}
			break;
		case IFNAME:
			if (!match && word != NULL && strlen(word) > 0) {
				if (strlcpy(res->ifname, word,
				    sizeof(res->ifname)) >=
				    sizeof(res->ifname))
					err(1, "interface name too long");
				match++;
				t = &table[i];
				if (t->value)
					res->action = t->value;
			}
			break;

		case ENDTOKEN:
			break;
		}
	}

	if (match != 1) {
		if (word == NULL)
			fprintf(stderr, "missing argument:\n");
		else if (match > 1)
			fprintf(stderr, "ambiguous argument: %s\n", word);
		else if (match < 1)
			fprintf(stderr, "unknown argument: %s\n", word);
		return (NULL);
	}

	return (t);
}

static void
show_valid_args(const struct token *table)
{
	int	i;

	for (i = 0; table[i].type != ENDTOKEN; i++) {
		switch (table[i].type) {
		case NOTOKEN:
			fprintf(stderr, "  <cr>\n");
			break;
		case KEYWORD:
		case FLAG:
			fprintf(stderr, "  %s\n", table[i].keyword);
			break;
		case FAMILY:
			fprintf(stderr, "  [ inet | inet6 | IPv4 | IPv6 ]\n");
			break;
		case ASNUM:
			fprintf(stderr, "  <asnum>\n");
			break;
		case ADDRESS:
			fprintf(stderr, "  <address>\n");
			break;
		case PREFIX:
			fprintf(stderr, "  <address>[/<len>]\n");
			break;
		case IFNAME:
			fprintf(stderr, "  <interface>\n");
			break;
		case ENDTOKEN:
			break;
		}
	}
}

int
parse_asnum(const char *word, uint16_t *asnum)
{
	const char	*errstr;
	uint32_t	 uval;

	if (word == NULL)
		return (0);

	uval = strtonum(word, EIGRP_MIN_AS, EIGRP_MAX_AS, &errstr);
	if (errstr)
		errx(1, "AS number is %s: %s", errstr, word);

	*asnum = uval;
	return (1);
}

int
parse_addr(const char *word, int *family, union eigrpd_addr *addr)
{
	struct in_addr		 ina;
	struct addrinfo		 hints, *r;
	struct sockaddr_in6	*sa_in6;

	if (word == NULL)
		return (0);

	memset(addr, 0, sizeof(union eigrpd_addr));
	memset(&ina, 0, sizeof(ina));

	if (inet_net_pton(AF_INET, word, &ina, sizeof(ina)) != -1) {
		*family = AF_INET;
		addr->v4.s_addr = ina.s_addr;
		return (1);
	}

	memset(&hints, 0, sizeof(hints));
	hints.ai_family = AF_INET6;
	hints.ai_socktype = SOCK_DGRAM; /*dummy*/
	hints.ai_flags = AI_NUMERICHOST;
	if (getaddrinfo(word, "0", &hints, &r) == 0) {
		sa_in6 = (struct sockaddr_in6 *)r->ai_addr;
		*family = AF_INET6;
		addr->v6 = sa_in6->sin6_addr;
		freeaddrinfo(r);
		return (1);
	}

	return (0);
}

int
parse_prefix(const char *word, int *family, union eigrpd_addr *addr,
    uint8_t *prefixlen)
{
	char		*p, *ps;
	const char	*errstr;
	size_t		 wordlen;
	int		 mask = -1;

	if (word == NULL)
		return (0);
	wordlen = strlen(word);

	memset(addr, 0, sizeof(union eigrpd_addr));

	if ((p = strrchr(word, '/')) != NULL) {
		size_t plen = strlen(p);
		mask = strtonum(p + 1, 0, 128, &errstr);
		if (errstr)
			errx(1, "netmask %s", errstr);

		if ((ps = malloc(wordlen - plen + 1)) == NULL)
			err(1, "parse_prefix: malloc");
		strlcpy(ps, word, wordlen - plen + 1);

		if (parse_addr(ps, family, addr) == 0) {
			free(ps);
			return (0);
		}

		free(ps);
	} else
		if (parse_addr(word, family, addr) == 0)
			return (0);

	switch (*family) {
	case AF_INET:
		if (mask == UINT8_MAX)
			mask = 32;
		if (mask > 32)
			errx(1, "invalid netmask: too large");
		break;
	case AF_INET6:
		if (mask == UINT8_MAX)
			mask = 128;
		if (mask > 128)
			errx(1, "invalid netmask: too large");
		break;
	default:
		return (0);
	}
	eigrp_applymask(*family, addr, addr, mask);
	*prefixlen = mask;

	return (1);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: parser.c,v 1.4 2016/01/15 12:57:49 renato Exp $ */
2
3			/*
4			* Copyright (c) 2015 Renato Westphal <renato@openbsd.org>
5			* Copyright (c) 2004 Esben Norby <norby@openbsd.org>
6			* Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
7			*
8			* Permission to use, copy, modify, and distribute this software for any
9			* purpose with or without fee is hereby granted, provided that the above
10			* copyright notice and this permission notice appear in all copies.
11			*
12			* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
13			* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
14			* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
15			* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
16			* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17			* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18			* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19			*/
20
21			#include <sys/types.h>
22			#include <sys/socket.h>
23			#include <netinet/in.h>
24			#include <arpa/inet.h>
25			#include <err.h>
26			#include <errno.h>
27			#include <limits.h>
28			#include <stdio.h>
29			#include <stdlib.h>
30			#include <string.h>
31			#include <netdb.h>
32
33			#include "eigrpd.h"
34
35			#include "parser.h"
36
37			enum token_type {
38			NOTOKEN,
39			ENDTOKEN,
40			KEYWORD,
41			FAMILY,
42			ASNUM,
43			ADDRESS,
44			FLAG,
45			PREFIX,
46			IFNAME
47			};
48
49			struct token {
50			enum token_type type;
51			const char *keyword;
52			int value;
53			const struct token *next;
54			};
55
56			static const struct token t_main[];
57			static const struct token t_fib[];
58			static const struct token t_show[];
59			static const struct token t_show_iface[];
60			static const struct token t_show_iface_af[];
61			static const struct token t_show_iface_as[];
62			static const struct token t_show_nbr[];
63			static const struct token t_show_nbr_af[];
64			static const struct token t_show_nbr_as[];
65			static const struct token t_show_topology[];
66			static const struct token t_show_topology_af[];
67			static const struct token t_show_topology_as[];
68			static const struct token t_show_fib[];
69			static const struct token t_show_fib_af[];
70			static const struct token t_show_stats[];
71			static const struct token t_show_stats_af[];
72			static const struct token t_show_stats_as[];
73			static const struct token t_log[];
74			static const struct token t_clear[];
75			static const struct token t_clear_nbr[];
76			static const struct token t_clear_nbr_af[];
77			static const struct token t_clear_nbr_as[];
78
79			static const struct token t_main[] = {
80			{KEYWORD, "reload", RELOAD, NULL},
81			{KEYWORD, "fib", FIB, t_fib},
82			{KEYWORD, "show", SHOW, t_show},
83			{KEYWORD, "clear", NONE, t_clear},
84			{KEYWORD, "log", NONE, t_log},
85			{ENDTOKEN, "", NONE, NULL}
86			};
87
88			static const struct token t_fib[] = {
89			{ KEYWORD, "couple", FIB_COUPLE, NULL},
90			{ KEYWORD, "decouple", FIB_DECOUPLE, NULL},
91			{ ENDTOKEN, "", NONE, NULL}
92			};
93
94			static const struct token t_show[] = {
95			{NOTOKEN, "", NONE, NULL},
96			{KEYWORD, "interfaces", SHOW_IFACE, t_show_iface},
97			{KEYWORD, "neighbor", SHOW_NBR, t_show_nbr},
98			{KEYWORD, "topology", SHOW_TOPOLOGY, t_show_topology},
99			{KEYWORD, "fib", SHOW_FIB, t_show_fib},
100			{KEYWORD, "traffic", SHOW_STATS, t_show_stats},
101			{ENDTOKEN, "", NONE, NULL}
102			};
103
104			static const struct token t_show_iface[] = {
105			{NOTOKEN, "", NONE, NULL},
106			{KEYWORD, "family", NONE, t_show_iface_af},
107			{KEYWORD, "as", NONE, t_show_iface_as},
108			{KEYWORD, "detail", SHOW_IFACE_DTAIL, NULL},
109			{IFNAME, "", SHOW_IFACE_DTAIL, NULL},
110			{ENDTOKEN, "", NONE, NULL}
111			};
112
113			static const struct token t_show_iface_af[] = {
114			{FAMILY, "", NONE, t_show_iface},
115			{ENDTOKEN, "", NONE, NULL}
116			};
117
118			static const struct token t_show_iface_as[] = {
119			{ASNUM, "", NONE, t_show_iface},
120			{ENDTOKEN, "", NONE, NULL}
121			};
122
123			static const struct token t_show_nbr[] = {
124			{NOTOKEN, "", NONE, NULL},
125			{KEYWORD, "family", NONE, t_show_nbr_af},
126			{KEYWORD, "as", NONE, t_show_nbr_as},
127			{ENDTOKEN, "", NONE, NULL}
128			};
129
130			static const struct token t_show_nbr_af[] = {
131			{FAMILY, "", NONE, t_show_nbr},
132			{ENDTOKEN, "", NONE, NULL}
133			};
134
135			static const struct token t_show_nbr_as[] = {
136			{ASNUM, "", NONE, t_show_nbr},
137			{ENDTOKEN, "", NONE, NULL}
138			};
139
140			static const struct token t_show_topology[] = {
141			{NOTOKEN, "", NONE, NULL},
142			{KEYWORD, "family", NONE, t_show_topology_af},
143			{KEYWORD, "as", NONE, t_show_topology_as},
144			{PREFIX, "", NONE, NULL},
145			{FLAG, "active", F_CTL_ACTIVE, NULL},
146			{FLAG, "all-links", F_CTL_ALLLINKS, NULL},
147			{ENDTOKEN, "", NONE, NULL}
148			};
149
150			static const struct token t_show_topology_af[] = {
151			{FAMILY, "", NONE, t_show_topology},
152			{ENDTOKEN, "", NONE, NULL}
153			};
154
155			static const struct token t_show_topology_as[] = {
156			{ASNUM, "", NONE, t_show_topology},
157			{ENDTOKEN, "", NONE, NULL}
158			};
159
160			static const struct token t_show_fib[] = {
161			{NOTOKEN, "", NONE, NULL},
162			{KEYWORD, "family", NONE, t_show_fib_af},
163			{KEYWORD, "interface", SHOW_FIB_IFACE, t_show_iface},
164			{FLAG, "connected", F_CONNECTED, t_show_fib},
165			{FLAG, "static", F_STATIC, t_show_fib},
166			{FLAG, "eigrp", F_EIGRPD_INSERTED, t_show_fib},
167			{ENDTOKEN, "", NONE, NULL}
168			};
169
170			static const struct token t_show_fib_af[] = {
171			{FAMILY, "", NONE, t_show_fib},
172			{ENDTOKEN, "", NONE, NULL}
173			};
174
175
176			static const struct token t_show_stats[] = {
177			{NOTOKEN, "", NONE, NULL},
178			{KEYWORD, "family", NONE, t_show_stats_af},
179			{KEYWORD, "as", NONE, t_show_stats_as},
180			{ENDTOKEN, "", NONE, NULL}
181			};
182
183			static const struct token t_show_stats_af[] = {
184			{FAMILY, "", NONE, t_show_stats},
185			{ENDTOKEN, "", NONE, NULL}
186			};
187
188			static const struct token t_show_stats_as[] = {
189			{ASNUM, "", NONE, t_show_stats},
190			{ENDTOKEN, "", NONE, NULL}
191			};
192
193			static const struct token t_clear[] = {
194			{KEYWORD, "neighbors", CLEAR_NBR, t_clear_nbr},
195			{ENDTOKEN, "", NONE, NULL}
196			};
197
198			static const struct token t_clear_nbr[] = {
199			{NOTOKEN, "", NONE, NULL},
200			{KEYWORD, "as", NONE, t_clear_nbr_as},
201			{KEYWORD, "family", NONE, t_clear_nbr_af},
202			{ADDRESS, "", NONE, NULL},
203			{ENDTOKEN, "", NONE, NULL}
204			};
205
206			static const struct token t_clear_nbr_af[] = {
207			{FAMILY, "", NONE, t_clear_nbr},
208			{ENDTOKEN, "", NONE, NULL}
209			};
210
211			static const struct token t_clear_nbr_as[] = {
212			{ASNUM, "", NONE, t_clear_nbr},
213			{ENDTOKEN, "", NONE, NULL}
214			};
215
216			static const struct token t_log[] = {
217			{KEYWORD, "verbose", LOG_VERBOSE, NULL},
218			{KEYWORD, "brief", LOG_BRIEF, NULL},
219			{ENDTOKEN, "", NONE, NULL}
220			};
221
222			static const struct token match_token(const char , const struct token *,
223			struct parse_result *);
224			static void show_valid_args(const struct token *);
225
226			struct parse_result *
227			parse(int argc, char *argv[])
228			{
229			static struct parse_result res;
230			const struct token *table = t_main;
231			const struct token *match;
232
233			memset(&res, 0, sizeof(res));
234
235			while (argc >= 0) {
236			if ((match = match_token(argv[0], table, &res)) == NULL) {
237			fprintf(stderr, "valid commands/args:\n");
238			show_valid_args(table);
239			return (NULL);
240			}
241
242			argc--;
243			argv++;
244
245			if (match->type == NOTOKEN \|\| match->next == NULL)
246			break;
247
248			table = match->next;
249			}
250
251			if (argc > 0) {
252			fprintf(stderr, "superfluous argument: %s\n", argv[0]);
253			return (NULL);
254			}
255
256			return (&res);
257			}
258
259			static const struct token *
260			match_token(const char word, const struct token table,
261			struct parse_result *res)
262			{
263			unsigned int i, match;
264			const struct token *t = NULL;
265
266			match = 0;
267
268			for (i = 0; table[i].type != ENDTOKEN; i++) {
269			switch (table[i].type) {
270			case NOTOKEN:
271			if (word == NULL \|\| strlen(word) == 0) {
272			match++;
273			t = &table[i];
274			}
275			break;
276			case KEYWORD:
277			if (word != NULL && strncmp(word, table[i].keyword,
278			strlen(word)) == 0) {
279			match++;
280			t = &table[i];
281			if (t->value)
282			res->action = t->value;
283			}
284			break;
285			case FLAG:
286			if (word != NULL && strncmp(word, table[i].keyword,
287			strlen(word)) == 0) {
288			match++;
289			t = &table[i];
290			res->flags \|= t->value;
291			}
292			break;
293			case FAMILY:
294			if (word == NULL)
295			break;
296			if (!strcmp(word, "inet") \|\|
297			!strcasecmp(word, "IPv4")) {
298			match++;
299			t = &table[i];
300			res->family = AF_INET;
301			}
302			if (!strcmp(word, "inet6") \|\|
303			!strcasecmp(word, "IPv6")) {
304			match++;
305			t = &table[i];
306			res->family = AF_INET6;
307			}
308			break;
309			case ASNUM:
310			if (parse_asnum(word, &res->as)) {
311			match++;
312			t = &table[i];
313			}
314			break;
315			case ADDRESS:
316			if (parse_addr(word, &res->family, &res->addr)) {
317			match++;
318			t = &table[i];
319			if (t->value)
320			res->action = t->value;
321			}
322			break;
323			case PREFIX:
324			if (parse_prefix(word, &res->family, &res->addr,
325			&res->prefixlen)) {
326			match++;
327			t = &table[i];
328			if (t->value)
329			res->action = t->value;
330			}
331			break;
332			case IFNAME:
333			if (!match && word != NULL && strlen(word) > 0) {
334			if (strlcpy(res->ifname, word,
335			sizeof(res->ifname)) >=
336			sizeof(res->ifname))
337			err(1, "interface name too long");
338			match++;
339			t = &table[i];
340			if (t->value)
341			res->action = t->value;
342			}
343			break;
344
345			case ENDTOKEN:
346			break;
347			}
348			}
349
350			if (match != 1) {
351			if (word == NULL)
352			fprintf(stderr, "missing argument:\n");
353			else if (match > 1)
354			fprintf(stderr, "ambiguous argument: %s\n", word);
355			else if (match < 1)
356			fprintf(stderr, "unknown argument: %s\n", word);
357			return (NULL);
358			}
359
360			return (t);
361			}
362
363			static void
364			show_valid_args(const struct token *table)
365			{
366			int i;
367
368			for (i = 0; table[i].type != ENDTOKEN; i++) {
369			switch (table[i].type) {
370			case NOTOKEN:
371			fprintf(stderr, " <cr>\n");
372			break;
373			case KEYWORD:
374			case FLAG:
375			fprintf(stderr, " %s\n", table[i].keyword);
376			break;
377			case FAMILY:
378			fprintf(stderr, " [ inet \| inet6 \| IPv4 \| IPv6 ]\n");
379			break;
380			case ASNUM:
381			fprintf(stderr, " <asnum>\n");
382			break;
383			case ADDRESS:
384			fprintf(stderr, " <address>\n");
385			break;
386			case PREFIX:
387			fprintf(stderr, " <address>[/<len>]\n");
388			break;
389			case IFNAME:
390			fprintf(stderr, " <interface>\n");
391			break;
392			case ENDTOKEN:
393			break;
394			}
395			}
396			}
397
398			int
399			parse_asnum(const char word, uint16_t asnum)
400			{
401			const char *errstr;
402			uint32_t uval;
403
404			if (word == NULL)
405			return (0);
406
407			uval = strtonum(word, EIGRP_MIN_AS, EIGRP_MAX_AS, &errstr);
408			if (errstr)
409			errx(1, "AS number is %s: %s", errstr, word);
410
411			*asnum = uval;
412			return (1);
413			}
414
415			int
416			parse_addr(const char word, int family, union eigrpd_addr *addr)
417			{
418			struct in_addr ina;
419			struct addrinfo hints, *r;
420			struct sockaddr_in6 *sa_in6;
421
422			if (word == NULL)
423			return (0);
424
425			memset(addr, 0, sizeof(union eigrpd_addr));
426			memset(&ina, 0, sizeof(ina));
427
428			if (inet_net_pton(AF_INET, word, &ina, sizeof(ina)) != -1) {
429			*family = AF_INET;
430			addr->v4.s_addr = ina.s_addr;
431			return (1);
432			}
433
434			memset(&hints, 0, sizeof(hints));
435			hints.ai_family = AF_INET6;
436			hints.ai_socktype = SOCK_DGRAM; /dummy/
437			hints.ai_flags = AI_NUMERICHOST;
438			if (getaddrinfo(word, "0", &hints, &r) == 0) {
439			sa_in6 = (struct sockaddr_in6 *)r->ai_addr;
440			*family = AF_INET6;
441			addr->v6 = sa_in6->sin6_addr;
442			freeaddrinfo(r);
443			return (1);
444			}
445
446			return (0);
447			}
448
449			int
450			parse_prefix(const char word, int family, union eigrpd_addr *addr,
451			uint8_t *prefixlen)
452			{
453			char p, ps;
454			const char *errstr;
455			size_t wordlen;
456			int mask = -1;
457
458			if (word == NULL)
459			return (0);
460			wordlen = strlen(word);
461
462			memset(addr, 0, sizeof(union eigrpd_addr));
463
464			if ((p = strrchr(word, '/')) != NULL) {
465			size_t plen = strlen(p);
466			mask = strtonum(p + 1, 0, 128, &errstr);
467			if (errstr)
468			errx(1, "netmask %s", errstr);
469
470			if ((ps = malloc(wordlen - plen + 1)) == NULL)
471			err(1, "parse_prefix: malloc");
472			strlcpy(ps, word, wordlen - plen + 1);
473
474			if (parse_addr(ps, family, addr) == 0) {
475			free(ps);
476			return (0);
477			}
478
479			free(ps);
480			} else
481			if (parse_addr(word, family, addr) == 0)
482			return (0);
483
484			switch (*family) {
485			case AF_INET:
486			if (mask == UINT8_MAX)
487			mask = 32;
488			if (mask > 32)
489			errx(1, "invalid netmask: too large");
490			break;
491			case AF_INET6:
492			if (mask == UINT8_MAX)
493			mask = 128;
494			if (mask > 128)
495			errx(1, "invalid netmask: too large");
496			break;
497			default:
498			return (0);
499			}
500			eigrp_applymask(*family, addr, addr, mask);
501			*prefixlen = mask;
502
503			return (1);
504			}