nl-cls-* tools

cli based tools to add/update/list/delete classifiers

1 files changed, 83 insertions, 61 deletions

diff --git a/src/nl-cls-delete.c b/src/nl-cls-delete.c
index cfdc170..0ffffb2 100644
--- a/src/nl-cls-delete.c
+++ b/src/nl-cls-delete.c
@@ -6,52 +6,59 @@
  *	License as published by the Free Software Foundation version 2.1
  *	of the License.
  *
- * Copyright (c) 2008 Thomas Graf <tgraf@suug.ch>
+ * Copyright (c) 2008-2010 Thomas Graf <tgraf@suug.ch>
  */
 
-#include "cls/utils.h"
+#include <netlink/cli/utils.h>
+#include <netlink/cli/cls.h>
+#include <netlink/cli/link.h>
 
-static int interactive = 0, default_yes = 0, quiet = 0;
-static int deleted = 0;
-static struct nl_sock *sock;
+static int quiet = 0, default_yes = 0, deleted = 0, interactive = 0;
+struct nl_sock *sock;
 
 static void print_usage(void)
 {
 	printf(
-	"Usage: nl-cls-list [OPTION]... [CLASSIFIER]\n"
-	"\n"
-	"Options\n"
-	" -i, --interactive     Run interactively\n"
-	"     --yes             Set default answer to yes\n"
-	" -q, --quiet		Do not print informal notifications\n"
-	" -h, --help            Show this help\n"
-	" -v, --version		Show versioning information\n"
-	"\n"
-	"Classifier Options\n"
-	" -d, --dev=DEV         Device the classifier should be assigned to.\n"
-	" -p, --parent=HANDLE   Parent qdisc/class\n"
-	"     --proto=PROTO     Protocol\n"
-	"     --prio=NUM        Priority (0..256)\n"
-	"     --id=HANDLE       Unique identifier\n"
+"Usage: nl-cls-delete [OPTION]... [class]\n"
+"\n"
+"OPTIONS\n"
+"     --interactive         Run interactively.\n"
+"     --yes                 Set default answer to yes.\n"
+" -q, --quiet               Do not print informal notifications.\n"
+" -h, --help                Show this help text and exit.\n"
+" -v, --version             Show versioning information and exit.\n"
+"\n"
+" -d, --dev=DEV             Device the classifer is attached to.\n"
+" -p, --parent=ID           Identifier of parent qdisc/class.\n"
+" -i, --id=ID               Identifier\n"
+" -k, --kind=NAME           Kind of classifier (e.g. basic, u32, fw)\n"
+"     --protocol=PROTO      Protocol to match (default: all)\n"
+"     --prio=PRIO           Priority (default: 0)\n"
+"\n"
+"EXAMPLE\n"
+"    # Delete all classifiers on eth0 attached to parent q_root:\n"
+"    $ nl-cls-delete --dev eth0 --parent q_root:\n"
+"\n"
 	);
+
 	exit(0);
 }
 
 static void delete_cb(struct nl_object *obj, void *arg)
 {
-	struct rtnl_cls *cls = (struct rtnl_cls *) obj;
+	struct rtnl_cls *cls = nl_object_priv(obj);
 	struct nl_dump_params params = {
 		.dp_type = NL_DUMP_LINE,
 		.dp_fd = stdout,
 	};
 	int err;
 
-	if (interactive && !nlt_confirm(obj, &params, default_yes))
+	if (interactive && !nl_cli_confirm(obj, &params, default_yes))
 		return;
 
 	if ((err = rtnl_cls_delete(sock, cls, 0)) < 0)
-		fatal(err, "Unable to delete classifier: %s",
-		      nl_geterror(err));
+		nl_cli_fatal(err, "Unable to delete classifier: %s\n",
+				nl_geterror(err));
 
 	if (!quiet) {
 		printf("Deleted ");
@@ -61,73 +68,88 @@ static void delete_cb(struct nl_object *obj, void *arg)
 	deleted++;
 }
 
-int main(int argc, char *argv[])
+static void __delete_link(int ifindex, struct rtnl_cls *filter)
 {
-	struct nl_cache *link_cache, *cls_cache;
-	struct rtnl_cls *cls;
-	int nf = 0, err;
+	struct nl_cache *cache;
+	uint32_t parent = rtnl_tc_get_parent((struct rtnl_tc *) filter);
+
+	cache = nl_cli_cls_alloc_cache(sock, ifindex, parent);
+	nl_cache_foreach_filter(cache, OBJ_CAST(filter), delete_cb, NULL);
+	nl_cache_free(cache);
+}
+
+static void delete_link(struct nl_object *obj, void *arg)
+{
+	struct rtnl_link *link = nl_object_priv(obj);
 
-	sock = nlt_alloc_socket();
-	nlt_connect(sock, NETLINK_ROUTE);
-	link_cache = nlt_alloc_link_cache(sock);
-	cls = nlt_alloc_cls();
+	__delete_link(rtnl_link_get_ifindex(link), arg);
+}
 
+int main(int argc, char *argv[])
+{
+	struct rtnl_cls *cls;
+	struct rtnl_tc *tc;
+	struct nl_cache *link_cache;
+	int ifindex;
+ 
+	sock = nl_cli_alloc_socket();
+	nl_cli_connect(sock, NETLINK_ROUTE);
+	link_cache = nl_cli_link_alloc_cache(sock);
+ 	cls = nl_cli_cls_alloc();
+	tc = (struct rtnl_tc *) cls;
+ 
 	for (;;) {
 		int c, optidx = 0;
 		enum {
-			ARG_PRIO = 257,
-			ARG_PROTO = 258,
-			ARG_ID,
-			ARG_YES,
+			ARG_YES = 257,
+			ARG_INTERACTIVE = 258,
+			ARG_PROTO,
+			ARG_PRIO,
 		};
 		static struct option long_opts[] = {
-			{ "interactive", 0, 0, 'i' },
+			{ "interactive", 0, 0, ARG_INTERACTIVE },
 			{ "yes", 0, 0, ARG_YES },
 			{ "quiet", 0, 0, 'q' },
 			{ "help", 0, 0, 'h' },
 			{ "version", 0, 0, 'v' },
 			{ "dev", 1, 0, 'd' },
 			{ "parent", 1, 0, 'p' },
+			{ "id", 1, 0, 'i' },
+			{ "kind", 1, 0, 'k' },
 			{ "proto", 1, 0, ARG_PROTO },
 			{ "prio", 1, 0, ARG_PRIO },
-			{ "id", 1, 0, ARG_ID },
 			{ 0, 0, 0, 0 }
 		};
 	
-		c = getopt_long(argc, argv, "iqhvd:p:", long_opts, &optidx);
+		c = getopt_long(argc, argv, "qhvd:p:i:k:", long_opts, &optidx);
 		if (c == -1)
 			break;
 
 		switch (c) {
-		case 'i': interactive = 1; break;
+		case '?': nl_cli_fatal(EINVAL, "Invalid options");
+		case ARG_INTERACTIVE: interactive = 1; break;
 		case ARG_YES: default_yes = 1; break;
 		case 'q': quiet = 1; break;
 		case 'h': print_usage(); break;
-		case 'v': nlt_print_version(); break;
-		case 'd': nf++; parse_dev(cls, link_cache, optarg); break;
-		case 'p': nf++; parse_parent(cls, optarg); break;
-		case ARG_PRIO: nf++; parse_prio(cls, optarg); break;
-		case ARG_ID: nf++; parse_handle(cls, optarg); break;
-		case ARG_PROTO: nf++; parse_proto(cls, optarg); break;
+		case 'v': nl_cli_print_version(); break;
+		case 'd': nl_cli_tc_parse_dev(tc, link_cache, optarg); break;
+		case 'p': nl_cli_tc_parse_parent(tc, optarg); break;
+		case 'i': nl_cli_tc_parse_handle(tc, optarg); break;
+		case 'k': nl_cli_cls_parse_kind(cls, optarg); break;
+		case ARG_PROTO: nl_cli_cls_parse_proto(cls, optarg); break;
+		case ARG_PRIO:
+			rtnl_cls_set_prio(cls, nl_cli_parse_u32(optarg));
+			break;
 		}
-	}
-
-	if (nf == 0 && !interactive && !default_yes) {
-		fprintf(stderr, "You attempted to delete all classifiers in "
-			"non-interactive mode, aborting.\n");
-		exit(0);
-	}
-
-	err = rtnl_cls_alloc_cache(sock, rtnl_cls_get_ifindex(cls),
-				   rtnl_cls_get_parent(cls), &cls_cache);
-	if (err < 0)
-		fatal(err, "Unable to allocate classifier cache: %s",
-		      nl_geterror(err));
+ 	}
 
-	nl_cache_foreach_filter(cls_cache, OBJ_CAST(cls), delete_cb, NULL);
+	if ((ifindex = rtnl_tc_get_ifindex(tc)))
+		__delete_link(ifindex, cls);
+	 else
+		nl_cache_foreach(link_cache, delete_link, cls);
 
 	if (!quiet)
-		printf("Deleted %d classifiers\n", deleted);
+		printf("Deleted %d classs\n", deleted);
 
 	return 0;
 }