int main(int argc, char *argv[])
{
struct rtnl_qdisc *qdisc;
struct rtnl_tc *tc;
struct nl_cache *link_cache, *qdisc_cache;
params.dp_fd = stdout;
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
qdisc_cache = nl_cli_qdisc_alloc_cache(sock);
qdisc = nl_cli_qdisc_alloc();
tc = (struct rtnl_tc *) qdisc;
for (;;) {
int c, optidx = 0;
enum {
ARG_DETAILS = 257,
ARG_STATS = 258,
};
static struct option long_opts[] = {
{ "details", 0, 0, ARG_DETAILS },
{ "stats", 0, 0, ARG_STATS },
{ "recursive", 0, 0, 'r' },
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'v' },
{ "dev", 1, 0, 'd' },
{ "parent", 1, 0, 'p' },
{ "id", 1, 0, 'i' },
{ "kind", 1, 0, 'k' },
{ 0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "rhvd:p:i:k:", long_opts, &optidx);
if (c == -1)
break;
switch (c) {
case ARG_DETAILS: params.dp_type = NL_DUMP_DETAILS; break;
case ARG_STATS: params.dp_type = NL_DUMP_STATS; break;
case 'r': recursive = 1; break;
case 'h': print_usage(); 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, 0); break;
case 'k': nl_cli_tc_parse_kind(tc, optarg); break;
}
}
if (recursive)
nl_cache_foreach_filter(qdisc_cache, OBJ_CAST(qdisc), list_qdisc, NULL);
else
nl_cache_dump_filter(qdisc_cache, ¶ms, OBJ_CAST(qdisc));
return 0;
}
static void __dump_link(int ifindex, struct rtnl_cls *filter)
{
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_dump_filter(cache, ¶ms, OBJ_CAST(filter));
nl_cache_free(cache);
}
int main(int argc, char *argv[])
{
struct nl_handle *nlh;
struct nl_cache *link_cache, *addr_cache;
struct rtnl_addr *addr;
struct nl_dump_params params = {
.dp_fd = stdout,
.dp_type = NL_DUMP_BRIEF
};
int err = 1;
if (nltool_init(argc, argv) < 0)
return -1;
nlh = nltool_alloc_handle();
if (!nlh)
return -1;
addr = rtnl_addr_alloc();
if (!addr)
goto errout;
if (argc < 2 || !strcmp(argv[1], "-h"))
print_usage();
if (nltool_connect(nlh, NETLINK_ROUTE) < 0)
goto errout_free;
link_cache = nltool_alloc_link_cache(nlh);
if (!link_cache)
goto errout_close;
addr_cache = nltool_alloc_addr_cache(nlh);
if (!addr_cache)
goto errout_link_cache;
params.dp_type = nltool_parse_dumptype(argv[1]);
if (params.dp_type < 0)
goto errout_addr_cache;
get_filter(addr, argc, argv, 2, link_cache);
nl_cache_dump_filter(addr_cache, ¶ms, (struct nl_object *) addr);
err = 0;
errout_addr_cache:
nl_cache_free(addr_cache);
errout_link_cache:
nl_cache_free(link_cache);
errout_close:
nl_close(nlh);
errout_free:
rtnl_addr_put(addr);
errout:
return err;
}
int main(int argc, char *argv[])
{
struct nl_sock *sock;
struct rtnl_neigh *neigh;
struct nl_cache *link_cache, *neigh_cache;
struct nl_dump_params params = {
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache_flags(sock, NL_CACHE_AF_ITER);
neigh_cache = nl_cli_neigh_alloc_cache(sock);
neigh = nl_cli_neigh_alloc();
for (;;) {
int c, optidx = 0;
enum {
ARG_FAMILY = 257,
ARG_STATE = 258,
};
static struct option long_opts[] = {
{ "format", 1, 0, 'f' },
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'v' },
{ "addr", 1, 0, 'a' },
{ "lladdr", 1, 0, 'l' },
{ "dev", 1, 0, 'd' },
{ "family", 1, 0, ARG_FAMILY },
{ "state", 1, 0, ARG_STATE },
{ 0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "f:hva:l:d:", long_opts, &optidx);
if (c == -1)
break;
switch (c) {
case 'f': params.dp_type = nl_cli_parse_dumptype(optarg); break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
case 'a': nl_cli_neigh_parse_dst(neigh, optarg); break;
case 'l': nl_cli_neigh_parse_lladdr(neigh, optarg); break;
case 'd': nl_cli_neigh_parse_dev(neigh, link_cache, optarg); break;
case ARG_FAMILY: nl_cli_neigh_parse_family(neigh, optarg); break;
case ARG_STATE: nl_cli_neigh_parse_state(neigh, optarg); break;
}
}
nl_cache_dump_filter(neigh_cache, ¶ms, OBJ_CAST(neigh));
return 0;
}
int main(int argc, char *argv[])
{
struct nl_sock *sock;
struct rtnl_rule *rule;
struct nl_cache *rule_cache;
struct nl_dump_params params = {
.dp_fd = stdout,
.dp_type = NL_DUMP_LINE,
};
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
nl_cli_link_alloc_cache(sock);
rule_cache = nl_cli_rule_alloc_cache(sock);
rule = nl_cli_rule_alloc();
for (;;) {
int c, optidx = 0;
enum {
ARG_FAMILY = 257,
};
static struct option long_opts[] = {
{ "format", 1, 0, 'f' },
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'v' },
{ "family", 1, 0, ARG_FAMILY },
{ 0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "f:hv", long_opts, &optidx);
if (c == -1)
break;
switch (c) {
case 'f': params.dp_type = nl_cli_parse_dumptype(optarg); break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
case ARG_FAMILY: nl_cli_rule_parse_family(rule, optarg); break;
}
}
nl_cache_dump_filter(rule_cache, ¶ms, OBJ_CAST(rule));
return 0;
}
static void print_cls(struct nl_object *obj, void *arg)
{
struct nl_cache *cls_cache;
int err, ifindex;
if (obj)
ifindex = rtnl_link_get_ifindex((struct rtnl_link *) obj);
else
ifindex = rtnl_cls_get_ifindex(cls);
err = rtnl_cls_alloc_cache(sock, ifindex, rtnl_cls_get_parent(cls),
&cls_cache);
if (err < 0)
fatal(err, "Unable to allocate classifier cache: %s",
nl_geterror(err));
nl_cache_dump_filter(cls_cache, ¶ms, OBJ_CAST(cls));
nl_cache_free(cls_cache);
}
int main(int argc, char *argv[])
{
struct nl_sock *sock;
struct nl_cache *link_cache, *route_cache;
struct rtnl_route *route;
struct nl_dump_params params = {
.dp_fd = stdout,
.dp_type = NL_DUMP_LINE,
};
int print_cache = 0;
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
route = nl_cli_route_alloc();
for (;;) {
int c, optidx = 0;
enum {
ARG_FAMILY = 257,
ARG_SRC = 258,
ARG_IIF,
ARG_PREF_SRC,
ARG_METRICS,
ARG_PRIORITY,
ARG_SCOPE,
ARG_PROTOCOL,
ARG_TYPE,
};
static struct option long_opts[] = {
{ "cache", 0, 0, 'c' },
{ "format", 1, 0, 'f' },
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'v' },
{ "dst", 1, 0, 'd' },
{ "nexthop", 1, 0, 'n' },
{ "table", 1, 0, 't' },
{ "family", 1, 0, ARG_FAMILY },
{ "src", 1, 0, ARG_SRC },
{ "iif", 1, 0, ARG_IIF },
{ "pref-src", 1, 0, ARG_PREF_SRC },
{ "metrics", 1, 0, ARG_METRICS },
{ "priority", 1, 0, ARG_PRIORITY },
{ "scope", 1, 0, ARG_SCOPE },
{ "protocol", 1, 0, ARG_PROTOCOL },
{ "type", 1, 0, ARG_TYPE },
{ 0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "cf:hvd:n:t:", long_opts, &optidx);
if (c == -1)
break;
switch (c) {
case 'c': print_cache = 1; break;
case 'f': params.dp_type = nl_cli_parse_dumptype(optarg); break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
case 'd': nl_cli_route_parse_dst(route, optarg); break;
case 'n': nl_cli_route_parse_nexthop(route, optarg, link_cache); break;
case 't': nl_cli_route_parse_table(route, optarg); break;
case ARG_FAMILY: nl_cli_route_parse_family(route, optarg); break;
case ARG_SRC: nl_cli_route_parse_src(route, optarg); break;
case ARG_IIF: nl_cli_route_parse_iif(route, optarg, link_cache); break;
case ARG_PREF_SRC: nl_cli_route_parse_pref_src(route, optarg); break;
case ARG_METRICS: nl_cli_route_parse_metric(route, optarg); break;
case ARG_PRIORITY: nl_cli_route_parse_prio(route, optarg); break;
case ARG_SCOPE: nl_cli_route_parse_scope(route, optarg); break;
case ARG_PROTOCOL: nl_cli_route_parse_protocol(route, optarg); break;
case ARG_TYPE: nl_cli_route_parse_type(route, optarg); break;
}
}
route_cache = nl_cli_route_alloc_cache(sock,
print_cache ? ROUTE_CACHE_CONTENT : 0);
nl_cache_dump_filter(route_cache, ¶ms, OBJ_CAST(route));
return 0;
}
int main(int argc, char *argv[])
{
struct nl_handle *nlh;
struct nl_cache *link_cache, *route_cache;
struct nl_addr *dst;
struct rtnl_route *route;
struct ip_lookup_res res;
struct nl_dump_params params = {
.dp_fd = stdout,
.dp_type = NL_DUMP_FULL
};
int err = 1;
if (argc < 2 || !strcmp(argv[1], "-h"))
print_usage();
if (nltool_init(argc, argv) < 0)
goto errout;
nlh = nltool_alloc_handle();
if (!nlh)
goto errout;
route = rtnl_route_alloc();
if (!route)
goto errout_free_handle;
if (nltool_connect(nlh, NETLINK_ROUTE) < 0)
goto errout_free_route;
link_cache = nltool_alloc_link_cache(nlh);
if (!link_cache)
goto errout_close;
dst = nltool_addr_parse(argv[1]);
if (!dst)
goto errout_link_cache;
route_cache = nltool_alloc_route_cache(nlh);
if (!route_cache)
goto errout_addr_put;
{
struct nl_msg *m;
struct rtmsg rmsg = {
.rtm_family = nl_addr_get_family(dst),
.rtm_dst_len = nl_addr_get_prefixlen(dst),
};
m = nlmsg_alloc_simple(RTM_GETROUTE, 0);
nlmsg_append(m, &rmsg, sizeof(rmsg), NLMSG_ALIGNTO);
nla_put_addr(m, RTA_DST, dst);
if ((err = nl_send_auto_complete(nlh, m)) < 0) {
nlmsg_free(m);
fprintf(stderr, "%s\n", nl_geterror());
goto errout_route_cache;
}
nlmsg_free(m);
nl_socket_modify_cb(nlh, NL_CB_VALID, NL_CB_CUSTOM, cb,
route_cache);
if (nl_recvmsgs_default(nlh) < 0) {
fprintf(stderr, "%s\n", nl_geterror());
goto errout_route_cache;
}
}
rtnl_route_set_dst(route, dst);
nl_cache_dump_filter(route_cache, ¶ms, (struct nl_object *) route);
memset(&res, 0, sizeof(res));
nl_cache_foreach_filter(route_cache, (struct nl_object *) route, route_proc_cb,
&res);
printf("ip lookup result: oif idx: %d oif name %s ",
res.oif, res.oifname);
if (res.nh_addr) {
char buf[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &res.nh_addr, buf, sizeof(buf));
printf("via %s", buf);
}
printf ("\n");
err = 0;
errout_route_cache:
nl_cache_free(route_cache);
errout_addr_put:
nl_addr_put(dst);
errout_link_cache:
nl_cache_free(link_cache);
errout_close:
nl_close(nlh);
errout_free_route:
rtnl_route_put(route);
errout_free_handle:
nl_handle_destroy(nlh);
errout:
return err;
}
int main(int argc, char *argv[])
{
struct nl_sock *sock;
struct nl_cache *exp_cache;
struct nfnl_exp *exp;
struct nl_dump_params params = {
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
exp = nl_cli_exp_alloc();
for (;;) {
int c, optidx = 0;
enum {
ARG_MARK = 270,
ARG_TCP_STATE = 271,
ARG_EXPECT_PROTO,
ARG_EXPECT_SRC,
ARG_EXPECT_SPORT,
ARG_EXPECT_DST,
ARG_EXPECT_DPORT,
ARG_MASTER_PROTO,
ARG_MASTER_SRC,
ARG_MASTER_SPORT,
ARG_MASTER_DST,
ARG_MASTER_DPORT,
ARG_TIMEOUT,
ARG_HELPER_NAME,
ARG_FLAGS,
};
static struct option long_opts[] = {
{ "format", 1, 0, 'f' },
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'v' },
{ "id", 1, 0, 'i' },
{ "expect-proto", 1, 0, ARG_EXPECT_PROTO },
{ "expect-src", 1, 0, ARG_EXPECT_SRC },
{ "expect-sport", 1, 0, ARG_EXPECT_SPORT },
{ "expect-dst", 1, 0, ARG_EXPECT_DST },
{ "expect-dport", 1, 0, ARG_EXPECT_DPORT },
{ "master-proto", 1, 0, ARG_MASTER_PROTO },
{ "master-src", 1, 0, ARG_MASTER_SRC },
{ "master-sport", 1, 0, ARG_MASTER_SPORT },
{ "master-dst", 1, 0, ARG_MASTER_DST },
{ "master-dport", 1, 0, ARG_MASTER_DPORT },
{ "family", 1, 0, 'F' },
{ "timeout", 1, 0, ARG_TIMEOUT },
{ "helper", 1, 0, ARG_HELPER_NAME },
{ "flags", 1, 0, ARG_FLAGS},
{ 0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "46f:hvi:p:F:", long_opts, &optidx);
if (c == -1)
break;
switch (c) {
case '?': exit(NLE_INVAL);
case '4': nfnl_exp_set_family(exp, AF_INET); break;
case '6': nfnl_exp_set_family(exp, AF_INET6); break;
case 'f': params.dp_type = nl_cli_parse_dumptype(optarg); break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
case 'i': nl_cli_exp_parse_id(exp, optarg); break;
case ARG_EXPECT_PROTO: nl_cli_exp_parse_l4protonum(exp, NFNL_EXP_TUPLE_EXPECT, optarg); break;
case ARG_EXPECT_SRC: nl_cli_exp_parse_src(exp, NFNL_EXP_TUPLE_EXPECT, optarg); break;
case ARG_EXPECT_SPORT: nl_cli_exp_parse_src_port(exp, NFNL_EXP_TUPLE_EXPECT, optarg); break;
case ARG_EXPECT_DST: nl_cli_exp_parse_dst(exp, NFNL_EXP_TUPLE_EXPECT, optarg); break;
case ARG_EXPECT_DPORT: nl_cli_exp_parse_dst_port(exp, NFNL_EXP_TUPLE_EXPECT, optarg); break;
case ARG_MASTER_PROTO: nl_cli_exp_parse_l4protonum(exp, NFNL_EXP_TUPLE_MASTER, optarg); break;
case ARG_MASTER_SRC: nl_cli_exp_parse_src(exp, NFNL_EXP_TUPLE_MASTER, optarg); break;
case ARG_MASTER_SPORT: nl_cli_exp_parse_src_port(exp, NFNL_EXP_TUPLE_MASTER, optarg); break;
case ARG_MASTER_DST: nl_cli_exp_parse_dst(exp, NFNL_EXP_TUPLE_MASTER, optarg); break;
case ARG_MASTER_DPORT: nl_cli_exp_parse_dst_port(exp, NFNL_EXP_TUPLE_MASTER, optarg); break;
case 'F': nl_cli_exp_parse_family(exp, optarg); break;
case ARG_TIMEOUT: nl_cli_exp_parse_timeout(exp, optarg); break;
case ARG_HELPER_NAME: nl_cli_exp_parse_helper_name(exp, optarg); break;
case ARG_FLAGS: nl_cli_exp_parse_flags(exp, optarg); break;
}
}
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_NETFILTER);
exp_cache = nl_cli_exp_alloc_cache(sock);
nl_cache_dump_filter(exp_cache, ¶ms, OBJ_CAST(exp));
return 0;
}
int main(int argc, char *argv[])
{
struct nl_sock *sock;
struct rtnl_addr *addr;
struct nl_cache *link_cache, *addr_cache;
struct nl_dump_params params = {
.dp_type = NL_DUMP_LINE,
.dp_nl_cb = print_prefix,
.dp_fd = stdout,
};
int dump_env = 0;
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link_cache = nl_cli_link_alloc_cache(sock);
addr_cache = nl_cli_addr_alloc_cache(sock);
addr = nl_cli_addr_alloc();
for (;;) {
int c, optidx = 0;
enum {
ARG_FAMILY = 257,
ARG_LABEL = 258,
ARG_PEER,
ARG_SCOPE,
ARG_BROADCAST,
ARG_DETAILS,
ARG_ENV,
ARG_PREFIX,
ARG_PREFERRED,
ARG_VALID,
};
static struct option long_opts[] = {
{ "details", 0, 0, ARG_DETAILS },
{ "env", 0, 0, ARG_ENV },
{ "prefix", 1, 0, ARG_PREFIX },
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'v' },
{ "local", 1, 0, 'a' },
{ "dev", 1, 0, 'd' },
{ "family", 1, 0, ARG_FAMILY },
{ "label", 1, 0, ARG_LABEL },
{ "peer", 1, 0, ARG_PEER },
{ "scope", 1, 0, ARG_SCOPE },
{ "broadcast", 1, 0, ARG_BROADCAST },
{ "preferred", 1, 0, ARG_PREFERRED },
{ "valid", 1, 0, ARG_VALID },
{ 0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "46hva:d:", long_opts, &optidx);
if (c == -1)
break;
switch (c) {
case '?': exit(NLE_INVAL);
case '4': rtnl_addr_set_family(addr, AF_INET); break;
case '6': rtnl_addr_set_family(addr, AF_INET6); break;
case ARG_DETAILS: params.dp_type = NL_DUMP_DETAILS; break;
case ARG_ENV: dump_env = 1; break;
case ARG_PREFIX: prefix = strdup(optarg); break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
case 'a': nl_cli_addr_parse_local(addr, optarg); break;
case 'd': nl_cli_addr_parse_dev(addr, link_cache, optarg); break;
case ARG_FAMILY: nl_cli_addr_parse_family(addr, optarg); break;
case ARG_LABEL: nl_cli_addr_parse_label(addr, optarg); break;
case ARG_PEER: nl_cli_addr_parse_peer(addr, optarg); break;
case ARG_SCOPE: nl_cli_addr_parse_scope(addr, optarg); break;
case ARG_BROADCAST: nl_cli_addr_parse_broadcast(addr, optarg); break;
case ARG_PREFERRED: nl_cli_addr_parse_preferred(addr, optarg); break;
case ARG_VALID: nl_cli_addr_parse_valid(addr, optarg); break;
}
}
if (dump_env)
nl_cache_foreach_filter(addr_cache, OBJ_CAST(addr), env_dump,
¶ms);
else
nl_cache_dump_filter(addr_cache, ¶ms, OBJ_CAST(addr));
return 0;
}
int main(int argc, char *argv[])
{
struct nl_sock *sock;
struct nl_cache *link_cache;
struct rtnl_link *link;
struct nl_dump_params params = {
.dp_type = NL_DUMP_LINE,
.dp_fd = stdout,
};
sock = nl_cli_alloc_socket();
nl_cli_connect(sock, NETLINK_ROUTE);
link = nl_cli_link_alloc();
for (;;) {
int c, optidx = 0;
enum {
ARG_FAMILY = 257,
ARG_MTU = 258,
ARG_TXQLEN,
ARG_WEIGHT,
ARG_DETAILS,
ARG_STATS,
};
static struct option long_opts[] = {
{ "details", 0, 0, ARG_DETAILS },
{ "stats", 0, 0, ARG_STATS },
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'v' },
{ "name", 1, 0, 'n' },
{ "index", 1, 0, 'i' },
{ "family", 1, 0, ARG_FAMILY },
{ "mtu", 1, 0, ARG_MTU },
{ "txqlen", 1, 0, ARG_TXQLEN },
{ "weight", 1, 0, ARG_WEIGHT },
{ 0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "hvn:i:", long_opts, &optidx);
if (c == -1)
break;
switch (c) {
case ARG_DETAILS: params.dp_type = NL_DUMP_DETAILS; break;
case ARG_STATS: params.dp_type = NL_DUMP_STATS; break;
case 'h': print_usage(); break;
case 'v': nl_cli_print_version(); break;
case 'n': nl_cli_link_parse_name(link, optarg); break;
case 'i': nl_cli_link_parse_ifindex(link, optarg); break;
case ARG_FAMILY: nl_cli_link_parse_family(link, optarg); break;
case ARG_MTU: nl_cli_link_parse_mtu(link, optarg); break;
case ARG_TXQLEN: nl_cli_link_parse_txqlen(link, optarg); break;
case ARG_WEIGHT: nl_cli_link_parse_weight(link, optarg); break;
}
}
link_cache = nl_cli_link_alloc_cache_family(sock,
rtnl_link_get_family(link));
nl_cache_dump_filter(link_cache, ¶ms, OBJ_CAST(link));
return 0;
}
