int main(int argc, char *argv[])
{
struct nl_sock *sock;
struct nl_msg *msg;
void *hdr;
int err;
sock = nlt_alloc_socket();
nlt_connect(sock, NETLINK_GENERIC);
msg = nlmsg_alloc();
if (msg == NULL)
fatal(NLE_NOMEM, "Unable to allocate netlink message");
hdr = genlmsg_put(msg, NL_AUTO_PID, NL_AUTO_SEQ, GENL_ID_CTRL,
0, 0, CTRL_CMD_GETFAMILY, 1);
if (hdr == NULL)
fatal(ENOMEM, "Unable to write genl header");
if ((err = nla_put_u32(msg, CTRL_ATTR_FAMILY_ID, GENL_ID_CTRL)) < 0)
fatal(err, "Unable to add attribute: %s", nl_geterror(err));
if ((err = nl_send_auto_complete(sock, msg)) < 0)
fatal(err, "Unable to send message: %s", nl_geterror(err));
if ((err = nl_recvmsgs_default(sock)) < 0)
fatal(err, "Unable to receive message: %s", nl_geterror(err));
nlmsg_free(msg);
nl_close(sock);
nl_socket_free(sock);
return 0;
}
int main(int argc, char *argv[])
{
struct nl_cache *link_cache;
int dev = 0;
params.dp_fd = stdout;
sock = nlt_alloc_socket();
nlt_connect(sock, NETLINK_ROUTE);
link_cache = nlt_alloc_link_cache(sock);
cls = nlt_alloc_cls();
for (;;) {
int c, optidx = 0;
enum {
ARG_PROTO = 257,
ARG_PRIO = 258,
ARG_ID,
};
static struct option long_opts[] = {
{ "format", 1, 0, 'f' },
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'v' },
{ "dev", 1, 0, 'd' },
{ "parent", 1, 0, 'p' },
{ "proto", 1, 0, ARG_PROTO },
{ "prio", 1, 0, ARG_PRIO },
{ "id", 1, 0, ARG_ID },
{ 0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "+f:qhva:d:", long_opts, &optidx);
if (c == -1)
break;
switch (c) {
case '?': exit(NLE_INVAL);
case 'f': params.dp_type = nlt_parse_dumptype(optarg); break;
case 'h': print_usage(); break;
case 'v': nlt_print_version(); break;
case 'd': dev = 1; parse_dev(cls, link_cache, optarg); break;
case 'p': parse_parent(cls, optarg); break;
case ARG_PRIO: parse_prio(cls, optarg); break;
case ARG_ID: parse_handle(cls, optarg); break;
case ARG_PROTO: parse_proto(cls, optarg); break;
}
}
if (!dev)
nl_cache_foreach(link_cache, print_cls, NULL);
else
print_cls(NULL, NULL);
return 0;
}
int main(int argc, char *argv[])
{
struct nl_cache_mngr *mngr;
struct nl_cache *lc, *nc, *ac, *rc;
struct nl_sock *sock;
int err;
signal(SIGINT, sigint);
sock = nlt_alloc_socket();
err = nl_cache_mngr_alloc(sock, NETLINK_ROUTE, NL_AUTO_PROVIDE, &mngr);
if (err < 0)
fatal(err, "Unable to allocate cache manager: %s",
nl_geterror(err));
if ((err = nl_cache_mngr_add(mngr, "route/link", &change_cb, &lc)) < 0)
fatal(err, "Unable to add cache route/link: %s",
nl_geterror(err));
if ((err = nl_cache_mngr_add(mngr, "route/neigh", &change_cb, &nc)) < 0)
fatal(err, "Unable to add cache route/neigh: %s",
nl_geterror(err));
if ((err = nl_cache_mngr_add(mngr, "route/addr", &change_cb, &ac)) < 0)
fatal(err, "Unable to add cache route/addr: %s",
nl_geterror(err));
if ((err = nl_cache_mngr_add(mngr, "route/route", &change_cb, &rc)) < 0)
fatal(err, "Unable to add cache route/route: %s",
nl_geterror(err));
while (!quit) {
int err = nl_cache_mngr_poll(mngr, 5000);
if (err < 0 && err != -NLE_INTR)
fatal(err, "Polling failed: %s", nl_geterror(err));
}
nl_cache_mngr_free(mngr);
nl_socket_free(sock);
return 0;
}
int main(int argc, char *argv[])
{
struct nl_sock *sock;
struct rtnl_cls *cls;
struct nl_cache *link_cache;
struct rtnl_cls_ops *ops;
struct cls_module *mod;
struct nl_dump_params dp = {
.dp_type = NL_DUMP_DETAILS,
.dp_fd = stdout,
};
char *kind;
int err, nlflags = NLM_F_CREATE;
sock = nlt_alloc_socket();
nlt_connect(sock, NETLINK_ROUTE);
link_cache = nlt_alloc_link_cache(sock);
cls = nlt_alloc_cls();
for (;;) {
int c, optidx = 0;
enum {
ARG_PROTO = 257,
ARG_PRIO = 258,
ARG_ID,
};
static struct option long_opts[] = {
{ "quiet", 0, 0, 'q' },
{ "help", 0, 0, 'h' },
{ "version", 0, 0, 'v' },
{ "dev", 1, 0, 'd' },
{ "parent", 1, 0, 'p' },
{ "proto", 1, 0, ARG_PROTO },
{ "prio", 1, 0, ARG_PRIO },
{ "id", 1, 0, ARG_ID },
{ 0, 0, 0, 0 }
};
c = getopt_long(argc, argv, "+qhva:d:", long_opts, &optidx);
if (c == -1)
break;
switch (c) {
case '?': exit(NLE_INVAL);
case 'q': quiet = 1; break;
case 'h': print_usage(); break;
case 'v': nlt_print_version(); break;
case 'd': parse_dev(cls, link_cache, optarg); break;
case 'p': parse_parent(cls, optarg); break;
case ARG_PRIO: parse_prio(cls, optarg); break;
case ARG_ID: parse_handle(cls, optarg); break;
case ARG_PROTO: parse_proto(cls, optarg); break;
}
}
if (optind >= argc) {
print_usage();
fatal(EINVAL, "Missing classifier type");
}
kind = argv[optind++];
if ((err = rtnl_cls_set_kind(cls, kind)) < 0)
fatal(ENOENT, "Unknown classifier type \"%s\".", kind);
ops = rtnl_cls_get_ops(cls);
if (!(mod = lookup_cls_mod(ops)))
fatal(ENOTSUP, "Classifier type \"%s\" not supported.", kind);
mod->parse_argv(cls, argc, argv);
printf("Adding ");
nl_object_dump(OBJ_CAST(cls), &dp);
if ((err = rtnl_cls_add(sock, cls, nlflags)) < 0)
fatal(err, "Unable to add classifier: %s", nl_geterror(err));
if (!quiet) {
printf("Added ");
nl_object_dump(OBJ_CAST(cls), &dp);
}
return 0;
}
