/*
* rule_flush_table_range: deletes all the rules which lookup the table X.
* The table X is any table in the range of `a' <= X <= `b'.
*/
int
rule_flush_table_range(int family, int a, int b)
{
struct rtnl_handle rth;
int arg[2];
if (rtnl_open(&rth, 0) < 0)
return 1;
if (rtnl_wilddump_request(&rth, family, RTM_GETRULE) < 0) {
error("Cannot dump the routing rule table");
return -1;
}
arg[0] = a;
arg[1] = b;
if (rtnl_dump_filter
(&rth, rule_flush_table_range_filter, arg, NULL, NULL) < 0) {
error("Flush terminated");
return -1;
}
rtnl_close(&rth);
return 0;
}
/*
* rule_flush_table_range_filter: rtnl_dump filter for
* rule_flush_table_range() (see below)
*/
int
rule_flush_table_range_filter(const struct sockaddr_nl *who,
struct nlmsghdr *n, void *arg)
{
struct rtnl_handle rth2;
struct rtmsg *r = NLMSG_DATA(n);
int len = n->nlmsg_len;
struct rtattr *tb[RTA_MAX + 1];
u_int a = *(u_int *) arg;
u_int b = *((u_int *) arg + 1);
len -= NLMSG_LENGTH(sizeof(*r));
if (len < 0)
return -1;
parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
if (tb[RTA_PRIORITY] && (r->rtm_table >= a && r->rtm_table <= b)) {
n->nlmsg_type = RTM_DELRULE;
n->nlmsg_flags = NLM_F_REQUEST;
if (rtnl_open(&rth2, 0) < 0)
return -1;
if (rtnl_talk(&rth2, n, 0, 0, NULL, NULL, NULL) < 0)
return -2;
rtnl_close(&rth2);
}
return 0;
}
static int flush_rule(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
{
struct rtnl_handle rth2;
struct rtmsg *r = NLMSG_DATA(n);
int len = n->nlmsg_len;
struct rtattr * tb[FRA_MAX+1];
len -= NLMSG_LENGTH(sizeof(*r));
if (len < 0)
return -1;
parse_rtattr(tb, FRA_MAX, RTM_RTA(r), len);
if (tb[FRA_PRIORITY]) {
n->nlmsg_type = RTM_DELRULE;
n->nlmsg_flags = NLM_F_REQUEST;
if (rtnl_open(&rth2, 0) < 0)
return -1;
if (rtnl_talk(&rth2, n, 0, 0, NULL, NULL, NULL) < 0)
return -2;
rtnl_close(&rth2);
}
return 0;
}
static void load_info(void)
{
struct ifstat_ent *db, *n;
struct rtnl_handle rth;
if (rtnl_open(&rth, 0) < 0)
exit(1);
if (rtnl_wilddump_request(&rth, AF_INET, RTM_GETLINK) < 0) {
perror("Cannot send dump request");
exit(1);
}
if (rtnl_dump_filter(&rth, get_netstat_nlmsg, NULL, NULL, NULL) < 0) {
fprintf(stderr, "Dump terminated\n");
exit(1);
}
rtnl_close(&rth);
db = kern_db;
kern_db = NULL;
while (db) {
n = db;
db = db->next;
n->next = kern_db;
kern_db = n;
}
}
void ipoe_nl_delete(int ifindex)
{
struct rtnl_handle rth;
struct nlmsghdr *nlh;
struct genlmsghdr *ghdr;
struct {
struct nlmsghdr n;
char buf[1024];
} req;
if (rtnl_open_byproto(&rth, 0, NETLINK_GENERIC)) {
log_ppp_error("ipoe: cannot open generic netlink socket\n");
return;
}
nlh = &req.n;
nlh->nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
nlh->nlmsg_type = ipoe_genl_id;
ghdr = NLMSG_DATA(&req.n);
ghdr->cmd = IPOE_CMD_DELETE;
addattr32(nlh, 128, IPOE_ATTR_IFINDEX, ifindex);
if (rtnl_talk(&rth, nlh, 0, 0, nlh, NULL, NULL, 0) < 0 )
log_ppp_error("ipoe: nl_delete: error talking to kernel\n");
rtnl_close(&rth);
}
int tc_qdisc_list(int argc, char **argv)
{
struct tcmsg t;
struct rtnl_handle rth;
char d[16];
memset(&t, 0, sizeof(t));
t.tcm_family = AF_UNSPEC;
memset(&d, 0, sizeof(d));
while (argc > 0) {
if (strcmp(*argv, "dev") == 0) {
NEXT_ARG();
strncpy(d, *argv, sizeof(d)-1);
#ifdef TC_H_INGRESS
} else if (strcmp(*argv, "ingress") == 0) {
if (t.tcm_parent) {
fprintf(stderr, "Duplicate parent ID\n");
usage();
}
t.tcm_parent = TC_H_INGRESS;
#endif
} else if (matches(*argv, "help") == 0) {
usage();
} else {
fprintf(stderr, "What is \"%s\"? Try \"tc qdisc help\".\n", *argv);
return -1;
}
argc--; argv++;
}
if (rtnl_open(&rth, 0) < 0) {
fprintf(stderr, "Cannot open rtnetlink\n");
exit(1);
}
ll_init_map(&rth);
if (d[0]) {
if ((t.tcm_ifindex = ll_name_to_index(d)) == 0) {
fprintf(stderr, "Cannot find device \"%s\"\n", d);
exit(1);
}
filter_ifindex = t.tcm_ifindex;
}
if (rtnl_dump_request(&rth, RTM_GETQDISC, &t, sizeof(t)) < 0) {
perror("Cannot send dump request");
exit(1);
}
if (rtnl_dump_filter(&rth, print_qdisc, stdout, NULL, NULL) < 0) {
fprintf(stderr, "Dump terminated\n");
exit(1);
}
rtnl_close(&rth);
return 0;
}
/*
* returns: -1 - address not found, 0 - addr is ok, 1 - addr is tentative
*/
int is_addr_tentative(char * ifacename, int iface, char * addr)
{
char buf[256];
char packed1[16];
char packed2[16];
struct rtattr * rta_tb[IFA_MAX+1];
struct nlmsg_list *ainfo = NULL;
struct nlmsg_list *head = NULL;
struct rtnl_handle rth;
int tentative = LOWLEVEL_TENTATIVE_DONT_KNOW;
inet_pton6(addr,packed1);
rtnl_open(&rth, 0);
/* 2nd attribute: AF_UNSPEC, AF_INET, AF_INET6 */
/* rtnl_wilddump_request(&rth, AF_PACKET, RTM_GETLINK); */
rtnl_wilddump_request(&rth, AF_INET6, RTM_GETADDR);
rtnl_dump_filter(&rth, store_nlmsg, &ainfo, NULL, NULL);
head = ainfo;
while (ainfo) {
struct nlmsghdr *n = &ainfo->h;
struct ifaddrmsg *ifa = NLMSG_DATA(n);
memset(rta_tb, 0, sizeof(*rta_tb));
if (ifa->ifa_index == iface && ifa->ifa_family==AF_INET6) {
parse_rtattr(rta_tb, IFA_MAX, IFA_RTA(ifa), n->nlmsg_len - NLMSG_LENGTH(sizeof(*ifa)));
if (!rta_tb[IFA_LOCAL]) rta_tb[IFA_LOCAL] = rta_tb[IFA_ADDRESS];
if (!rta_tb[IFA_ADDRESS]) rta_tb[IFA_ADDRESS] = rta_tb[IFA_LOCAL];
inet_ntop6(RTA_DATA(rta_tb[IFA_LOCAL]), buf /*, sizeof(buf)*/);
memcpy(packed2,RTA_DATA(rta_tb[IFA_LOCAL]),16);
/* print_packed(packed1); printf(" "); print_packed(packed2); printf("\n"); */
/* is this addr which are we looking for? */
if (!memcmp(packed1,packed2,16) ) {
if (ifa->ifa_flags & IFA_F_TENTATIVE)
tentative = LOWLEVEL_TENTATIVE_YES;
else
tentative = LOWLEVEL_TENTATIVE_NO;
}
}
ainfo = ainfo->next;
}
/* now delete list */
while (head) {
ainfo = head;
head = head->next;
free(ainfo);
}
rtnl_close(&rth);
return tentative;
}
int
iface_gre_del(const char *gre_iface)
{
struct softgred_config *cfg = softgred_config_ref();
int ret;
errno = 0;
if ((ret=rtnl_open(&cfg->rth, 0)) < 0)
{
D_DEBUG1("Cannot open rtnetlink\n");
return EXIT_FAILURE;
}
if(!iplink_have_newlink())
{
D_DEBUG1("iplink_have_newlink ret=%d strerror='%s'\n", ret, strerror(errno));
}
else
{
ret = iplink_modify(RTM_DELLINK, 0, gre_iface, NULL, NULL, NULL, NULL);
if (ret != 0)
{
D_DEBUG1("iplink_modify(RTM_DELLINK) ret=%d strerror='%s'\n", ret, strerror(errno));
}
}
rtnl_close(&cfg->rth);
return 1;
}
/****************************************************************
NAME : ipaddr_list 00/06/02 20:02:23
AIM :
REMARK :
****************************************************************/
int ipaddr_list( int ifindex, uint32_t *array, int max_elem )
{
struct rtnl_handle rth;
iplist_ctx ctx;
/* init the struct */
ctx.ifindex = ifindex;
ctx.addr = array;
ctx.max_elem = max_elem;
ctx.nb_elem = 0;
/* open the rtnetlink socket */
if( rtnl_open( &rth, 0) )
return -1;
/* send the request */
if (rtnl_wilddump_request(&rth, AF_INET, RTM_GETADDR) < 0) {
perror("Cannot send dump request");
return -1;
}
/* parse the answer */
if (rtnl_dump_filter(&rth, get_addrinfo, &ctx, NULL, NULL) < 0) {
fprintf(stderr, "Flush terminated\n");
exit(1);
}
/* to close the clocket */
rtnl_close( &rth );
return ctx.nb_elem;
}
/** Initialize interface table
*
* Initialize rtnl interface and interface table
* Call this before any nlif_* function
*
* \return file descriptor to netlink socket
*/
struct nlif_handle *nlif_open(void)
{
struct nlif_handle *h;
h = calloc(1, sizeof(struct nlif_handle));
if (h == NULL)
goto err;
h->ifadd_handler.nlmsg_type = RTM_NEWLINK;
h->ifadd_handler.handlefn = iftable_add;
h->ifadd_handler.arg = h;
h->ifdel_handler.nlmsg_type = RTM_DELLINK;
h->ifdel_handler.handlefn = iftable_del;
h->ifdel_handler.arg = h;
h->rtnl_handle = rtnl_open();
if (h->rtnl_handle == NULL)
goto err;
if (rtnl_handler_register(h->rtnl_handle, &h->ifadd_handler) < 0)
goto err_close;
if (rtnl_handler_register(h->rtnl_handle, &h->ifdel_handler) < 0)
goto err_unregister;
return h;
err_unregister:
rtnl_handler_unregister(h->rtnl_handle, &h->ifdel_handler);
err_close:
rtnl_close(h->rtnl_handle);
free(h);
err:
return NULL;
}
int route_del(struct sockaddr_storage *destination, struct sockaddr_storage *gateway,int prefix,unsigned int metric){
struct rtnl_handle rth;
// structure of the netlink packet.
struct{
struct nlmsghdr n;
struct rtmsg r;
char buf[1024];
} req;
char mxbuf[256];
struct rtattr * mxrta = (void*)mxbuf;
//unsigned mxlock = 0;
memset(&req, 0, sizeof(req));
// Initialisation of a few parameters
req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
req.n.nlmsg_flags = NLM_F_REQUEST|NLM_F_CREATE;
req.n.nlmsg_type = RTM_DELROUTE;
req.r.rtm_family = destination->ss_family;
req.r.rtm_table = get_eigrp_routing_table_number();
req.r.rtm_dst_len = prefix;
req.r.rtm_protocol = get_eigrp_routing_protocol_number();
req.r.rtm_scope = RT_SCOPE_UNIVERSE;
req.r.rtm_type = RTN_UNICAST;
mxrta->rta_type = RTA_METRICS;
mxrta->rta_len = RTA_LENGTH(0);
// RTA_DST and RTA_GW are the two esential parameters for adding a route
// for ipv4, the length of the address is 4 bytes.
if(destination->ss_family == AF_INET){
struct sockaddr_in *dest = (struct sockaddr_in *)destination;
struct sockaddr_in *gate = (struct sockaddr_in *)gateway;
addattr_l(&req.n, sizeof(req), RTA_DST, &dest->sin_addr.s_addr, 4);
addattr_l(&req.n, sizeof(req), RTA_GATEWAY, &gate->sin_addr.s_addr, 4);
}else{
struct sockaddr_in6 *dest = (struct sockaddr_in6 *)destination;
struct sockaddr_in6 *gate = (struct sockaddr_in6 *)gateway;
addattr_l(&req.n, sizeof(req), RTA_DST, &dest->sin6_addr.s6_addr, sizeof(dest->sin6_addr.s6_addr));
addattr_l(&req.n, sizeof(req), RTA_GATEWAY, &gate->sin6_addr.s6_addr, sizeof(dest->sin6_addr.s6_addr));
}
addattr_l(&req.n, sizeof(req), RTA_PRIORITY, &metric, sizeof(metric));
int status = 0;
// opening the netlink socket to communicate with the kernel
if (rtnl_open(&rth, 0) < 0){
printf("cannot open rtnetlink\n");
return -1;
}
// sending the packet to the kernel.
status = rtnl_talk(&rth, &req.n, 0, 0, NULL);
if (status < 0)
return status;
rtnl_close(&rth);
return 0;
}
static int xfrm_spd_getinfo(int argc, char **argv)
{
struct rtnl_handle rth;
struct {
struct nlmsghdr n;
__u32 flags;
char ans[128];
} req;
memset(&req, 0, sizeof(req));
req.n.nlmsg_len = NLMSG_LENGTH(sizeof(__u32));
req.n.nlmsg_flags = NLM_F_REQUEST;
req.n.nlmsg_type = XFRM_MSG_GETSPDINFO;
req.flags = 0XFFFFFFFF;
if (rtnl_open_byproto(&rth, 0, NETLINK_XFRM) < 0)
exit(1);
if (rtnl_talk(&rth, &req.n, 0, 0, &req.n, NULL, NULL) < 0)
exit(2);
print_spdinfo(&req.n, (void*)stdout);
rtnl_close(&rth);
return 0;
}
int
main(int argc, char **argv)
{
while (argc > 1) {
char *opt = argv[1];
if (strcmp(opt,"--") == 0) {
argc--; argv++;
break;
}
if (opt[0] != '-')
break;
if (opt[1] == '-')
opt++;
if (matches(opt, "-help") == 0) {
usage();
} else if (matches(opt, "-Version") == 0) {
printf("bridge utility, 0.0\n");
exit(0);
} else if (matches(opt, "-stats") == 0 ||
matches(opt, "-statistics") == 0) {
++show_stats;
} else if (matches(opt, "-details") == 0) {
++show_details;
} else if (matches(opt, "-timestamp") == 0) {
++timestamp;
} else if (matches(opt, "-family") == 0) {
argc--;
argv++;
if (argc <= 1)
usage();
if (strcmp(argv[1], "inet") == 0)
preferred_family = AF_INET;
else if (strcmp(argv[1], "inet6") == 0)
preferred_family = AF_INET6;
else if (strcmp(argv[1], "help") == 0)
usage();
else
invarg("invalid protocol family", argv[1]);
} else if (strcmp(opt, "-4") == 0) {
preferred_family = AF_INET;
} else if (strcmp(opt, "-6") == 0) {
preferred_family = AF_INET6;
} else {
fprintf(stderr, "Option \"%s\" is unknown, try \"bridge help\".\n", opt);
exit(-1);
}
argc--; argv++;
}
if (rtnl_open(&rth, 0) < 0)
exit(1);
if (argc > 1)
return do_cmd(argv[1], argc-1, argv+1);
rtnl_close(&rth);
usage();
}
int main(int argc, char **argv)
{
int ret;
int do_batching = 0;
char *batchfile = NULL;
while (argc > 1) {
if (argv[1][0] != '-')
break;
if (matches(argv[1], "-stats") == 0 ||
matches(argv[1], "-statistics") == 0) {
++show_stats;
} else if (matches(argv[1], "-details") == 0) {
++show_details;
} else if (matches(argv[1], "-raw") == 0) {
++show_raw;
} else if (matches(argv[1], "-pretty") == 0) {
++show_pretty;
} else if (matches(argv[1], "-Version") == 0) {
printf("tc utility, iproute2-ss%s\n", SNAPSHOT);
return 0;
} else if (matches(argv[1], "-iec") == 0) {
++use_iec;
} else if (matches(argv[1], "-help") == 0) {
usage();
return 0;
} else if (matches(argv[1], "-force") == 0) {
++force;
} else if (matches(argv[1], "-batch") == 0) {
do_batching = 1;
if (argc > 2)
batchfile = argv[2];
argc--; argv++;
} else {
fprintf(stderr, "Option \"%s\" is unknown, try \"tc -help\".\n", argv[1]);
return -1;
}
argc--; argv++;
}
if (do_batching)
return batch(batchfile);
if (argc <= 1) {
usage();
return 0;
}
tc_core_init();
if (rtnl_open(&rth, 0) < 0) {
fprintf(stderr, "Cannot open rtnetlink\n");
exit(1);
}
ret = do_cmd(argc-1, argv+1);
rtnl_close(&rth);
return ret;
}
int do_monitor(int argc, char **argv)
{
char *file = NULL;
unsigned groups = ~RTMGRP_TC;
int llink=0;
int lneigh=0;
rtnl_close(&rth);
while (argc > 0) {
if (matches(*argv, "file") == 0) {
NEXT_ARG();
file = *argv;
} else if (matches(*argv, "link") == 0) {
llink=1;
groups = 0;
} else if (matches(*argv, "fdb") == 0) {
lneigh = 1;
groups = 0;
} else if (strcmp(*argv, "all") == 0) {
groups = ~RTMGRP_TC;
prefix_banner=1;
} else if (matches(*argv, "help") == 0) {
usage();
} else {
fprintf(stderr, "Argument \"%s\" is unknown, try \"bridge monitor help\".\n", *argv);
exit(-1);
}
argc--; argv++;
}
if (llink)
groups |= nl_mgrp(RTNLGRP_LINK);
if (lneigh) {
groups |= nl_mgrp(RTNLGRP_NEIGH);
}
if (file) {
FILE *fp;
fp = fopen(file, "r");
if (fp == NULL) {
perror("Cannot fopen");
exit(-1);
}
return rtnl_from_file(fp, accept_msg, stdout);
}
if (rtnl_open(&rth, groups) < 0)
exit(1);
ll_init_map(&rth);
if (rtnl_listen(&rth, accept_msg, stdout) < 0)
exit(2);
return 0;
}
int do_tcmonitor(int argc, char **argv)
{
struct rtnl_handle rth;
char *file = NULL;
unsigned groups = nl_mgrp(RTNLGRP_TC);
while (argc > 0) {
if (matches(*argv, "file") == 0) {
NEXT_ARG();
file = *argv;
} else {
if (matches(*argv, "help") == 0) {
usage();
} else {
fprintf(stderr, "Argument \"%s\" is unknown, try \"tc monitor help\".\n", *argv);
exit(-1);
}
}
argc--; argv++;
}
if (file) {
FILE *fp;
fp = fopen(file, "r");
if (fp == NULL) {
perror("Cannot fopen");
exit(-1);
}
return rtnl_from_file(fp, accept_tcmsg, (void*)stdout);
}
if (rtnl_open(&rth, groups) < 0)
exit(1);
ll_init_map(&rth);
if (rtnl_listen(&rth, accept_tcmsg, (void*)stdout) < 0) {
rtnl_close(&rth);
exit(2);
}
rtnl_close(&rth);
exit(0);
}
/** Destructor of interface table
*
* \param nlif_handle A pointer to a ::nlif_handle created
* via nlif_open()
*/
void nlif_close(struct nlif_handle *h)
{
assert(h != NULL);
rtnl_handler_unregister(h->rtnl_handle, &h->ifadd_handler);
rtnl_handler_unregister(h->rtnl_handle, &h->ifdel_handler);
rtnl_close(h->rtnl_handle);
free(h);
h = NULL; /* bugtrap */
}
int ipaddr_op( int ifindex, uint32_t addr, uint8_t length, int addF )
{
struct rtnl_handle rth;
struct {
struct nlmsghdr n;
struct ifaddrmsg ifa;
char buf[256];
} req;
uint32_t bcast;
memset(&req, 0, sizeof(req));
req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
req.n.nlmsg_flags = NLM_F_REQUEST;
req.n.nlmsg_type = addF ? RTM_NEWADDR : RTM_DELADDR;
req.ifa.ifa_family = AF_INET;
req.ifa.ifa_index = ifindex;
req.ifa.ifa_prefixlen = 32;
req.ifa.ifa_prefixlen = length;
addr = htonl( addr );
addattr_l(&req.n, sizeof(req), IFA_LOCAL, &addr, sizeof(addr) );
bcast = addr | htonl((1 << (32 - length)) - 1);
addattr_l(&req.n, sizeof(req), IFA_BROADCAST, &bcast, sizeof(bcast) );
if (rtnl_open(&rth, 0) < 0){
rtnl_close( &rth );
return -1;
}
if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0) {
rtnl_close( &rth );
return -1;
}
/* to close the clocket */
rtnl_close( &rth );
return(0);
}
int rtnl_iterate(int proto, int type, rtnl_filter_t func, void *extarg)
{
struct rtnl_handle rth;
if (rtnl_open_byproto(&rth, 0, proto) < 0)
return -1;
if (rtnl_wilddump_request(&rth, AF_INET6, type) < 0) {
rtnl_close(&rth);
return -1;
}
if (rtnl_dump_filter(&rth, func, extarg, NULL, NULL) < 0) {
rtnl_close(&rth);
return -1;
}
rtnl_close(&rth);
return 0;
}
/*
* main body of the program
*/
int
main(int argc,
char * argv[])
{
struct rtnl_handle rth;
int opt;
/* Check command line options */
while((opt = getopt_long(argc, argv, "hv", long_opts, NULL)) > 0)
{
switch(opt)
{
case 'h':
iw_usage(0);
break;
case 'v':
return(iw_print_version_info("iwevent"));
break;
default:
iw_usage(1);
break;
}
}
if(optind < argc)
{
fputs("Too many arguments.\n", stderr);
iw_usage(1);
}
/* Open netlink channel */
if(rtnl_open(&rth, RTMGRP_LINK) < 0)
{
perror("Can't initialize rtnetlink socket");
return(1);
}
#if WIRELESS_EXT > 13
fprintf(stderr, "Waiting for Wireless Events...\n");
#else /* WIRELESS_EXT > 13 */
fprintf(stderr, "Unsupported in Wireless Extensions <= 14 :-(\n");
return(-1);
#endif /* WIRELESS_EXT > 13 */
/* Do what we have to do */
wait_for_event(&rth);
/* Cleanup - only if you are pedantic */
rtnl_close(&rth);
return(0);
}
int rtnl_do(int proto, struct nlmsghdr *sn, struct nlmsghdr *rn)
{
struct rtnl_handle rth;
int err;
if (rtnl_open_byproto(&rth, 0, proto) < 0) {
dbg("ERROR \n");
return -1;
}
err = rtnl_talk(&rth, sn, 0, 0, rn, NULL, NULL);
rtnl_close(&rth);
return err;
}
int test_look_interface_changes(){
struct rtnl_handle rth;
if (rtnl_open(&rth, RTNLGRP_LINK) < 0){
printf("cannot open rtnetlink\n");
return -1;
}
int status = rtnl_listen(&rth,test_handle,0);
rtnl_close(&rth);
return status;
}
int look_interface_changes(){
if (rtnl_open(&rtnl_interface, RTNLGRP_LINK) < 0){
printf("cannot open rtnetlink\n");
return -1;
}
int status = rtnl_listen(&rtnl_interface,handle,0);
rtnl_close(&rtnl_interface);
printf("RTNL OFF\n");
return status;
}
static int xfrm_policy_flush(int argc, char **argv)
{
struct rtnl_handle rth;
struct {
struct nlmsghdr n;
char buf[RTA_BUF_SIZE];
} req;
char *ptypep = NULL;
struct xfrm_userpolicy_type upt;
memset(&req, 0, sizeof(req));
memset(&upt, 0, sizeof(upt));
req.n.nlmsg_len = NLMSG_LENGTH(0); /* nlmsg data is nothing */
req.n.nlmsg_flags = NLM_F_REQUEST;
req.n.nlmsg_type = XFRM_MSG_FLUSHPOLICY;
while (argc > 0) {
if (strcmp(*argv, "ptype") == 0) {
if (ptypep)
duparg("ptype", *argv);
ptypep = *argv;
NEXT_ARG();
xfrm_policy_ptype_parse(&upt.type, &argc, &argv);
filter.dir_mask = XFRM_FILTER_MASK_FULL;
} else
invarg("unknown", *argv);
argc--; argv++;
}
if (ptypep) {
addattr_l(&req.n, sizeof(req), XFRMA_POLICY_TYPE,
(void *)&upt, sizeof(upt));
}
if (rtnl_open_byproto(&rth, 0, NETLINK_XFRM) < 0)
exit(1);
if (show_stats > 1)
fprintf(stderr, "Flush policy\n");
if (rtnl_talk(&rth, &req.n, 0, 0, NULL, NULL, NULL) < 0)
exit(2);
rtnl_close(&rth);
return 0;
}
int cthd_nl_wrapper::genl_get_family_status(char *family_name, int type)
{
struct rtnl_handle rth;
struct nlmsghdr *nlh;
struct genlmsghdr *ghdr;
int ret = -1;
struct {
struct nlmsghdr n;
char buf[4096];
} req;
memset(&req, 0, sizeof(req));
nlh = &req.n;
nlh->nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
nlh->nlmsg_type = GENL_ID_CTRL;
ghdr = (struct genlmsghdr *)NLMSG_DATA(&req.n);
ghdr->cmd = CTRL_CMD_GETFAMILY;
/* send CTRL_CMD_GET_FAMILY message to controller */
if (rtnl_open_byproto(&rth, 0, NETLINK_GENERIC) < 0) {
fprintf(stderr, "Cannot open generic netlink socket\n");
exit(1);
}
addattr_l(nlh, 128, CTRL_ATTR_FAMILY_NAME,
family_name, strlen(family_name) + 1);
if (rtnl_talk(&rth, nlh, 0, 0, nlh, NULL, NULL) < 0) {
fprintf(stderr, "Error talking to the kernel\n");
goto ctrl_done;
}
if (type) {
if (genl_get_mcast_group_id(nlh))
fprintf(stderr,
"Failed to get acpi_event multicast group\n");
} else
if (genl_print_ctrl_message(NULL, nlh, (void *)stdout) < 0)
fprintf(stderr,
"Failed to print acpi_event family status\n");
ret = 0;
ctrl_done:
rtnl_close(&rth);
return ret;
}
void add_classes() {
// call dump of classes, these needs to be dumped on per device basis
struct tcmsg t;
struct rtnl_handle rth;
char d[16];
char line[1024];
FILE *dev;
char *p;
memset(&rth,0,sizeof(struct rtnl_handle));
memset(&t, 0, sizeof(t));
t.tcm_family = AF_UNSPEC;
memset(&d, 0, sizeof(d));
if (rtnl_open(&rth, 0) < 0) {
snmp_log(LOG_NOTICE, "Cannot open rtnetlink");
return;
}
dev=fopen("/proc/net/dev","r");
if(dev==NULL) {
snmp_log(LOG_WARNING,"qos-ext: cannot open /proc/net/dev for reading, class stats won't be avaiable");
return;
}
while(fscanf(dev,"%s",line)!=EOF) {
//find existing devices
p=index(line,':'); if(p==NULL) continue;
*p='\0';
// line contains device_name.... need to translate name into index
t.tcm_ifindex = ll_name_to_index(line);
if (rtnl_dump_request(&rth, RTM_GETTCLASS, &t, sizeof(t)) < 0) {
//dump all classes on device with index t.tcm_ifindex
snmp_log(LOG_WARNING,"qos-ext: add_new_entries to table: cannot send dump request");
fclose(dev);
return;
}
if (rtnl_dump_filter(&rth, insert_entry, NULL, NULL, NULL) < 0) {
//append all classes entris into the internal table
snmp_log(LOG_WARNING, "qos-ext: add_new entries to table: class dump terminated");
fclose(dev);
return;
}
}
fclose(dev);
rtnl_close(&rth);
}
int ipoe_nl_modify(int ifindex, uint32_t peer_addr, uint32_t addr, const char *ifname, uint8_t *hwaddr)
{
struct rtnl_handle rth;
struct nlmsghdr *nlh;
struct genlmsghdr *ghdr;
int ret = 0;
struct {
struct nlmsghdr n;
char buf[1024];
} req;
union {
uint8_t hwaddr[6];
uint64_t u64;
} u;
if (rtnl_open_byproto(&rth, 0, NETLINK_GENERIC)) {
log_ppp_error("ipoe: cannot open generic netlink socket\n");
return -1;
}
nlh = &req.n;
nlh->nlmsg_len = NLMSG_LENGTH(GENL_HDRLEN);
nlh->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
nlh->nlmsg_type = ipoe_genl_id;
ghdr = NLMSG_DATA(&req.n);
ghdr->cmd = IPOE_CMD_MODIFY;
addattr32(nlh, 1024, IPOE_ATTR_IFINDEX, ifindex);
addattr32(nlh, 1024, IPOE_ATTR_PEER_ADDR, peer_addr);
addattr32(nlh, 1024, IPOE_ATTR_ADDR, addr);
if (hwaddr) {
memcpy(u.hwaddr, hwaddr, 6);
addattr_l(nlh, 1024, IPOE_ATTR_HWADDR, &u.u64, 8);
}
if (ifname)
addattr_l(nlh, 1024, IPOE_ATTR_IFNAME, ifname, strlen(ifname) + 1);
if (rtnl_talk(&rth, nlh, 0, 0, nlh, NULL, NULL, 0) < 0 ) {
log_ppp_error("ipoe: nl_create: error talking to kernel\n");
ret = -1;
}
rtnl_close(&rth);
return ret;
}
/*
* if_init_all: it initializes all the `ifs_n'# interfaces present in the
* `ifs' array. If `ifs_n' is zero it gets all the current up interfaces and
* stores them in `new_ifs', updating the `new_ifs_n' counter too. Then it
* initializes them.
* In the `new_ifs' array, which must be at least big as the `ids' array, it
* stores all the initialized interfaces, updating the `new_ifs_n' counter.
* On error -1 is returned.
*/
int if_init_all(char *ifs_name[MAX_INTERFACES], int ifs_n,
interface *new_ifs, int *new_ifs_n)
{
struct rtnl_handle rth;
int ret=0, i, n;
if (rtnl_open(&rth, 0) < 0) {
error("Cannot open the rtnetlink socket to talk to the kernel's "
"soul");
return -1;
}
ll_init_map(&rth);
if(!ifs_n) {
ret=get_all_up_ifs(new_ifs, MAX_INTERFACES);
if(!ret)
return -1;
*new_ifs_n=ret;
} else {
for(i=0, n=0; i<ifs_n; i++) {
new_ifs[n].dev_idx=ll_name_to_index(ifs_name[n]);
if(!new_ifs[n].dev_idx) {
error("Cannot initialize the %s interface. "
"Ignoring it", ifs_name[n]);
continue;
}
strncpy(new_ifs[n].dev_name, ifs_name[n], IFNAMSIZ);
n++;
}
if(!n)
return -1;
*new_ifs_n=n;
}
if(set_all_ifs(new_ifs, *new_ifs_n, set_dev_up) < 0)
return -1;
rtnl_close(&rth);
return ret;
}
void list(void) {
struct rtnl_handle rth;
if (rtnl_open(&rth,0)) {
perror("Cannot open rtnetlink");
return;
}
if (rtnl_wilddump_request(&rth, AF_UNSPEC, RTM_GETLINK) < 0) {
perror("Cannot send dump request");
return;
}
if (rtnl_dump_filter(&rth, print_link, NULL) < 0) {
fprintf(stderr, "Dump terminated\n");
return;
}
rtnl_close(&rth);
}
static int flush_addrlabel(const struct sockaddr_nl *who, struct nlmsghdr *n, void *arg)
{
struct rtnl_handle rth2;
struct rtmsg *r = NLMSG_DATA(n);
int len = n->nlmsg_len;
struct rtattr * tb[IFAL_MAX+1];
len -= NLMSG_LENGTH(sizeof(*r));
if (len < 0)
return -1;
parse_rtattr(tb, IFAL_MAX, RTM_RTA(r), len);
if (tb[IFAL_ADDRESS]) {
n->nlmsg_type = RTM_DELADDRLABEL;
n->nlmsg_flags = NLM_F_REQUEST;
if (rtnl_open(&rth2, 0) < 0)
return -1;
if (rtnl_talk(&rth2, n, NULL, 0) < 0)
return -2;
rtnl_close(&rth2);
}
return 0;
}
