rtnetlink.c File Reference

#include <linux/config.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/socket.h>
#include <linux/kernel.h>
#include <linux/major.h>
#include <linux/sched.h>
#include <linux/timer.h>
#include <linux/string.h>
#include <linux/sockios.h>
#include <linux/net.h>
#include <linux/fcntl.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/capability.h>
#include <linux/skbuff.h>
#include <linux/init.h>
#include <asm/uaccess.h>
#include <asm/system.h>
#include <asm/string.h>
#include <linux/inet.h>
#include <linux/netdevice.h>
#include <net/ip.h>
#include <net/protocol.h>
#include <net/arp.h>
#include <net/route.h>
#include <net/udp.h>
#include <net/sock.h>
#include <net/pkt_sched.h>

Go to the source code of this file.

Functions
	DECLARE_MUTEX (rtnl_sem)
void	rtnl_lock (void)
void	rtnl_unlock (void)
int	rtattr_parse (struct rtattr *tb[], int maxattr, struct rtattr *rta, int len)
void	__rta_fill (struct sk_buff *skb, int attrtype, int attrlen, const void *data)
int	rtnetlink_send (struct sk_buff *skb, u32 pid, unsigned group, int echo)
int	rtnetlink_put_metrics (struct sk_buff *skb, unsigned *metrics)
int	rtnetlink_fill_ifinfo (struct sk_buff *skb, struct net_device *dev, int type, u32 pid, u32 seq, u32 change)
int	rtnetlink_dump_ifinfo (struct sk_buff *skb, struct netlink_callback *cb)
int	rtnetlink_dump_all (struct sk_buff *skb, struct netlink_callback *cb)
void	rtmsg_ifinfo (int type, struct net_device *dev, unsigned change)
int	rtnetlink_done (struct netlink_callback *cb)
__inline__ int	rtnetlink_rcv_msg (struct sk_buff *skb, struct nlmsghdr *nlh, int *errp)
int	rtnetlink_rcv_skb (struct sk_buff *skb)
void	rtnetlink_rcv (struct sock *sk, int len)
int	rtnetlink_event (struct notifier_block *this, unsigned long event, void *ptr)
void __init	rtnetlink_init (void)
Variables
sock *	rtnl
rtnetlink_link *	rtnetlink_links [NPROTO]
const int	rtm_min [(RTM_MAX+1-RTM_BASE)/4]
const int	rta_max [(RTM_MAX+1-RTM_BASE)/4]
rtnetlink_link	link_rtnetlink_table [RTM_MAX-RTM_BASE+1]
notifier_block	rtnetlink_dev_notifier

---

Function Documentation

void __rta_fill (  struct sk_buff *  skb, int  attrtype, int  attrlen, const void *  data )

Definition at line 107 of file rtnetlink.c. References skb_put(). { struct rtattr *rta; int size = RTA_LENGTH(attrlen); rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size)); rta->rta_type = attrtype; rta->rta_len = size; memcpy(RTA_DATA(rta), data, attrlen); }

DECLARE_MUTEX (  rtnl_sem   )

int rtattr_parse (  struct rtattr *  tb[], int  maxattr, struct rtattr *  rta, int  len )

Definition at line 66 of file rtnetlink.c. { memset(tb, 0, sizeof(struct rtattr*)*maxattr); while (RTA_OK(rta, len)) { unsigned flavor = rta->rta_type; if (flavor && flavor <= maxattr) tb[flavor-1] = rta; rta = RTA_NEXT(rta, len); } return 0; }

void rtmsg_ifinfo (  int  type, struct net_device *  dev, unsigned  change )

Definition at line 247 of file rtnetlink.c. References alloc_skb(), kfree_skb(), netlink_broadcast(), NETLINK_CB, NLMSG_GOODSIZE, rtnetlink_fill_ifinfo(), and rtnl. Referenced by dev_change_flags(), netdev_set_master(), netdev_state_change(), and rtnetlink_event(). { struct sk_buff *skb; int size = NLMSG_GOODSIZE; skb = alloc_skb(size, GFP_KERNEL); if (!skb) return; if (rtnetlink_fill_ifinfo(skb, dev, type, 0, 0, change) < 0) { kfree_skb(skb); return; } NETLINK_CB(skb).dst_groups = RTMGRP_LINK; netlink_broadcast(rtnl, skb, 0, RTMGRP_LINK, GFP_KERNEL); }

int rtnetlink_done (  struct netlink_callback *  cb  )  [static]

Definition at line 264 of file rtnetlink.c. Referenced by rtnetlink_rcv_msg(). { return 0; }

int rtnetlink_dump_all (  struct sk_buff *  skb, struct netlink_callback *  cb )

Definition at line 223 of file rtnetlink.c. References netlink_callback::args, netlink_callback::family, sk_buff::len, netlink_callback::nlh, nlmsghdr::nlmsg_type, NPROTO, and rtnetlink_links. { int idx; int s_idx = cb->family; if (s_idx == 0) s_idx = 1; for (idx=1; idx<NPROTO; idx++) { int type = cb->nlh->nlmsg_type-RTM_BASE; if (idx < s_idx || idx == PF_PACKET) continue; if (rtnetlink_links[idx] == NULL || rtnetlink_links[idx][type].dumpit == NULL) continue; if (idx > s_idx) memset(&cb->args[0], 0, sizeof(cb->args)); if (rtnetlink_links[idx][type].dumpit(skb, cb)) break; } cb->family = idx; return skb->len; }

int rtnetlink_dump_ifinfo (  struct sk_buff *  skb, struct netlink_callback *  cb )

Definition at line 204 of file rtnetlink.c. References netlink_callback::args, dev_base, dev_base_lock, sk_buff::len, NETLINK_CB, net_device::next, netlink_callback::nlh, nlmsghdr::nlmsg_seq, rtnetlink_fill_ifinfo(), and netlink_callback::skb. { int idx; int s_idx = cb->args[0]; struct net_device *dev; read_lock(&dev_base_lock); for (dev=dev_base, idx=0; dev; dev = dev->next, idx++) { if (idx < s_idx) continue; if (rtnetlink_fill_ifinfo(skb, dev, RTM_NEWLINK, NETLINK_CB(cb->skb).pid, cb->nlh->nlmsg_seq, 0) <= 0) break; } read_unlock(&dev_base_lock); cb->args[0] = idx; return skb->len; }

int rtnetlink_event (  struct notifier_block *  this, unsigned long  event, void *  ptr )  [static]

Definition at line 487 of file rtnetlink.c. References rtmsg_ifinfo(). { struct net_device *dev = ptr; switch (event) { case NETDEV_UNREGISTER: rtmsg_ifinfo(RTM_DELLINK, dev, ~0U); break; case NETDEV_REGISTER: rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U); break; case NETDEV_UP: case NETDEV_DOWN: rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING); break; case NETDEV_CHANGE: case NETDEV_GOING_DOWN: break; default: rtmsg_ifinfo(RTM_NEWLINK, dev, 0); break; } return NOTIFY_DONE; }

int rtnetlink_fill_ifinfo (  struct sk_buff *  skb, struct net_device *  dev, int  type, u32  pid, u32  seq, u32  change )  [static]

Definition at line 152 of file rtnetlink.c. References net_device::addr_len, net_device::broadcast, sk_buff::data, net_device::dev_addr, net_device::flags, net_device::get_stats, Qdisc_ops::id, net_device::ifindex, net_device::iflink, sk_buff::len, net_device::master, net_device::mtu, net_device::name, netif_carrier_ok(), netif_running(), NLM_F_MULTI, NLMSG_DATA, NLMSG_PUT, Qdisc::ops, net_device::qdisc_sleeping, skb_trim(), sk_buff::tail, and net_device::type. Referenced by rtmsg_ifinfo(), and rtnetlink_dump_ifinfo(). { struct ifinfomsg *r; struct nlmsghdr *nlh; unsigned char *b = skb->tail; nlh = NLMSG_PUT(skb, pid, seq, type, sizeof(*r)); if (pid) nlh->nlmsg_flags |= NLM_F_MULTI; r = NLMSG_DATA(nlh); r->ifi_family = AF_UNSPEC; r->ifi_type = dev->type; r->ifi_index = dev->ifindex; r->ifi_flags = dev->flags; r->ifi_change = change; if (!netif_running(dev) || !netif_carrier_ok(dev)) r->ifi_flags &= ~IFF_RUNNING; else r->ifi_flags |= IFF_RUNNING; RTA_PUT(skb, IFLA_IFNAME, strlen(dev->name)+1, dev->name); if (dev->addr_len) { RTA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr); RTA_PUT(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast); } if (1) { unsigned mtu = dev->mtu; RTA_PUT(skb, IFLA_MTU, sizeof(mtu), &mtu); } if (dev->ifindex != dev->iflink) RTA_PUT(skb, IFLA_LINK, sizeof(int), &dev->iflink); if (dev->qdisc_sleeping) RTA_PUT(skb, IFLA_QDISC, strlen(dev->qdisc_sleeping->ops->id) + 1, dev->qdisc_sleeping->ops->id); if (dev->master) RTA_PUT(skb, IFLA_MASTER, sizeof(int), &dev->master->ifindex); if (dev->get_stats) { struct net_device_stats *stats = dev->get_stats(dev); if (stats) RTA_PUT(skb, IFLA_STATS, sizeof(*stats), stats); } nlh->nlmsg_len = skb->tail - b; return skb->len; nlmsg_failure: rtattr_failure: skb_trim(skb, b - skb->data); return -1; }

void __init rtnetlink_init (  void   )

Definition at line 518 of file rtnetlink.c. References link_rtnetlink_table, netlink_kernel_create(), NETLINK_ROUTE, netlink_set_nonroot(), NL_NONROOT_RECV, register_netdevice_notifier(), rtnetlink_dev_notifier, rtnetlink_links, rtnetlink_rcv(), and rtnl. Referenced by sock_init(). { #ifdef RTNL_DEBUG printk("Initializing RT netlink socket\n"); #endif rtnl = netlink_kernel_create(NETLINK_ROUTE, rtnetlink_rcv); if (rtnl == NULL) panic("rtnetlink_init: cannot initialize rtnetlink\n"); netlink_set_nonroot(NETLINK_ROUTE, NL_NONROOT_RECV); register_netdevice_notifier(&rtnetlink_dev_notifier); rtnetlink_links[PF_UNSPEC] = link_rtnetlink_table; rtnetlink_links[PF_PACKET] = link_rtnetlink_table; }

int rtnetlink_put_metrics (  struct sk_buff *  skb, unsigned *  metrics )

Definition at line 131 of file rtnetlink.c. References sk_buff::data, skb_trim(), and sk_buff::tail. Referenced by fib_dump_info(), and rt_fill_info(). { struct rtattr *mx = (struct rtattr*)skb->tail; int i; RTA_PUT(skb, RTA_METRICS, 0, NULL); for (i=0; i<RTAX_MAX; i++) { if (metrics[i]) RTA_PUT(skb, i+1, sizeof(unsigned), metrics+i); } mx->rta_len = skb->tail - (u8*)mx; if (mx->rta_len == RTA_LENGTH(0)) skb_trim(skb, (u8*)mx - skb->data); return 0; rtattr_failure: skb_trim(skb, (u8*)mx - skb->data); return -1; }

void rtnetlink_rcv (  struct sock *  sk, int  len )  [static]

Definition at line 435 of file rtnetlink.c. References kfree_skb(), sk_buff_head::qlen, sock::receive_queue, rtnetlink_rcv_skb(), rtnl, skb_dequeue(), and skb_queue_head(). Referenced by rtnetlink_init(). { do { struct sk_buff *skb; if (rtnl_shlock_nowait()) return; while ((skb = skb_dequeue(&sk->receive_queue)) != NULL) { if (rtnetlink_rcv_skb(skb)) { if (skb->len) skb_queue_head(&sk->receive_queue, skb); else kfree_skb(skb); break; } kfree_skb(skb); } up(&rtnl_sem); } while (rtnl && rtnl->receive_queue.qlen); }

__inline__ int rtnetlink_rcv_msg (  struct sk_buff *  skb, struct nlmsghdr *  nlh, int *  errp )  [static]

Definition at line 272 of file rtnetlink.c. References sk_buff::len, NETLINK_CB, netlink_dump_start(), NLM_F_DUMP, NLM_F_REQUEST, NLMSG_ALIGN, NLMSG_DATA, nlmsghdr::nlmsg_flags, nlmsghdr::nlmsg_len, NLMSG_LENGTH, nlmsghdr::nlmsg_type, NPROTO, rta_max, rtm_min, rtnetlink_done(), rtnetlink_links, rtnl, and skb_pull(). Referenced by rtnetlink_rcv_skb(). { struct rtnetlink_link *link; struct rtnetlink_link *link_tab; struct rtattr *rta[RTATTR_MAX]; int exclusive = 0; int sz_idx, kind; int min_len; int family; int type; int err; /* Only requests are handled by kernel now */ if (!(nlh->nlmsg_flags&NLM_F_REQUEST)) return 0; type = nlh->nlmsg_type; /* A control message: ignore them */ if (type < RTM_BASE) return 0; /* Unknown message: reply with EINVAL */ if (type > RTM_MAX) goto err_inval; type -= RTM_BASE; /* All the messages must have at least 1 byte length */ if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtgenmsg))) return 0; family = ((struct rtgenmsg*)NLMSG_DATA(nlh))->rtgen_family; if (family > NPROTO) { *errp = -EAFNOSUPPORT; return -1; } link_tab = rtnetlink_links[family]; if (link_tab == NULL) link_tab = rtnetlink_links[PF_UNSPEC]; link = &link_tab[type]; sz_idx = type>>2; kind = type&3; if (kind != 2 && !cap_raised(NETLINK_CB(skb).eff_cap, CAP_NET_ADMIN)) { *errp = -EPERM; return -1; } if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) { u32 rlen; if (link->dumpit == NULL) link = &(rtnetlink_links[PF_UNSPEC][type]); if (link->dumpit == NULL) goto err_inval; if ((*errp = netlink_dump_start(rtnl, skb, nlh, link->dumpit, rtnetlink_done)) != 0) { return -1; } rlen = NLMSG_ALIGN(nlh->nlmsg_len); if (rlen > skb->len) rlen = skb->len; skb_pull(skb, rlen); return -1; } if (kind != 2) { if (rtnl_exlock_nowait()) { *errp = 0; return -1; } exclusive = 1; } memset(&rta, 0, sizeof(rta)); min_len = rtm_min[sz_idx]; if (nlh->nlmsg_len < min_len) goto err_inval; if (nlh->nlmsg_len > min_len) { int attrlen = nlh->nlmsg_len - NLMSG_ALIGN(min_len); struct rtattr *attr = (void*)nlh + NLMSG_ALIGN(min_len); while (RTA_OK(attr, attrlen)) { unsigned flavor = attr->rta_type; if (flavor) { if (flavor > rta_max[sz_idx]) goto err_inval; rta[flavor-1] = attr; } attr = RTA_NEXT(attr, attrlen); } } if (link->doit == NULL) link = &(rtnetlink_links[PF_UNSPEC][type]); if (link->doit == NULL) goto err_inval; err = link->doit(skb, nlh, (void *)&rta); if (exclusive) rtnl_exunlock(); *errp = err; return err; err_inval: if (exclusive) rtnl_exunlock(); *errp = -EINVAL; return -1; }

int rtnetlink_rcv_skb (  struct sk_buff *  skb  )  [inline, static]

Definition at line 397 of file rtnetlink.c. References sk_buff::data, sk_buff::len, netlink_ack(), NLM_F_ACK, NLMSG_ALIGN, NLMSG_SPACE, rtnetlink_rcv_msg(), and skb_pull(). Referenced by rtnetlink_rcv(). { int err; struct nlmsghdr * nlh; while (skb->len >= NLMSG_SPACE(0)) { u32 rlen; nlh = (struct nlmsghdr *)skb->data; if (nlh->nlmsg_len < sizeof(*nlh) || skb->len < nlh->nlmsg_len) return 0; rlen = NLMSG_ALIGN(nlh->nlmsg_len); if (rlen > skb->len) rlen = skb->len; if (rtnetlink_rcv_msg(skb, nlh, &err)) { /* Not error, but we must interrupt processing here: * Note, that in this case we do not pull message * from skb, it will be processed later. */ if (err == 0) return -1; netlink_ack(skb, nlh, err); } else if (nlh->nlmsg_flags&NLM_F_ACK) netlink_ack(skb, nlh, 0); skb_pull(skb, rlen); } return 0; }

int rtnetlink_send (  struct sk_buff *  skb, u32  pid, unsigned  group, int  echo )

Definition at line 118 of file rtnetlink.c. References netlink_broadcast(), NETLINK_CB, netlink_unicast(), rtnl, and sk_buff::users. { int err = 0; NETLINK_CB(skb).dst_groups = group; if (echo) atomic_inc(&skb->users); netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL); if (echo) err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT); return err; }

void rtnl_lock (  void   )

Definition at line 54 of file rtnetlink.c. Referenced by arp_ioctl(), dev_ioctl(), devinet_ioctl(), ip_mc_drop_socket(), ip_mc_leave_group(), ip_mroute_setsockopt(), ip_rt_ioctl(), mrtsock_destruct(), and setup_inject(). { rtnl_shlock(); rtnl_exlock(); }

void rtnl_unlock (  void   )

Definition at line 60 of file rtnetlink.c. Referenced by arp_ioctl(), dev_ioctl(), devinet_ioctl(), ip_mc_drop_socket(), ip_mc_leave_group(), ip_mroute_setsockopt(), ip_rt_ioctl(), mrtsock_destruct(), and setup_inject(). { rtnl_exunlock(); rtnl_shunlock(); }

---

Variable Documentation

struct rtnetlink_link link_rtnetlink_table[RTM_MAX-RTM_BASE+1] [static]

Initial value: { { NULL, NULL, }, { NULL, NULL, }, { NULL, rtnetlink_dump_ifinfo, }, { NULL, NULL, }, { NULL, NULL, }, { NULL, NULL, }, { NULL, rtnetlink_dump_all, }, { NULL, NULL, }, { NULL, NULL, }, { NULL, NULL, }, { NULL, rtnetlink_dump_all, }, { NULL, NULL, }, { neigh_add, NULL, }, { neigh_delete, NULL, }, { NULL, neigh_dump_info, }, { NULL, NULL, }, { NULL, NULL, }, { NULL, NULL, }, { NULL, NULL, }, { NULL, NULL, }, } Definition at line 458 of file rtnetlink.c. Referenced by rtnetlink_init().

const int rta_max[(RTM_MAX+1-RTM_BASE)/4] [static]

Initial value: { IFLA_MAX, IFA_MAX, RTA_MAX, NDA_MAX, RTA_MAX, TCA_MAX, TCA_MAX, TCA_MAX } Definition at line 95 of file rtnetlink.c. Referenced by rtnetlink_rcv_msg().

const int rtm_min[(RTM_MAX+1-RTM_BASE)/4] [static]

Initial value: { NLMSG_LENGTH(sizeof(struct ifinfomsg)), NLMSG_LENGTH(sizeof(struct ifaddrmsg)), NLMSG_LENGTH(sizeof(struct rtmsg)), NLMSG_LENGTH(sizeof(struct ndmsg)), NLMSG_LENGTH(sizeof(struct rtmsg)), NLMSG_LENGTH(sizeof(struct tcmsg)), NLMSG_LENGTH(sizeof(struct tcmsg)), NLMSG_LENGTH(sizeof(struct tcmsg)) } Definition at line 83 of file rtnetlink.c. Referenced by rtnetlink_rcv_msg().

struct notifier_block rtnetlink_dev_notifier

Initial value: { rtnetlink_event, NULL, 0 } Definition at line 511 of file rtnetlink.c. Referenced by rtnetlink_init().

struct rtnetlink_link* rtnetlink_links[NPROTO]

Definition at line 81 of file rtnetlink.c. Referenced by devinet_init(), rtnetlink_dump_all(), rtnetlink_init(), and rtnetlink_rcv_msg().

struct sock* rtnl

Definition at line 79 of file rtnetlink.c. Referenced by inet_rtm_getroute(), ipmr_cache_resolve(), ipmr_destroy_unres(), rtmsg_fib(), rtmsg_ifa(), rtmsg_ifinfo(), rtmsg_iwinfo(), rtnetlink_init(), rtnetlink_rcv(), rtnetlink_rcv_msg(), and rtnetlink_send().

---