/* * 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; }