mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-05 18:14:07 +08:00
83b496e928
rtnl_setlink doesn't allow to change subsets of the flags, just to override the set entirely by a new one. This means that for simply setting a device up or down userspace first needs to query the current flags, change it and send the changed flags back, which is racy and needlessly complicated. Mask the flags using ifi_change since this is what it is intended for. For backwards compatibility treat ifi_change == 0 as ~0 (even though it seems quite unlikely that anyone has been using this so far). Signed-off-by: Patrick McHardy <kaber@trash.net> Signed-off-by: David S. Miller <davem@davemloft.net>
977 lines
24 KiB
C
977 lines
24 KiB
C
/*
|
|
* INET An implementation of the TCP/IP protocol suite for the LINUX
|
|
* operating system. INET is implemented using the BSD Socket
|
|
* interface as the means of communication with the user level.
|
|
*
|
|
* Routing netlink socket interface: protocol independent part.
|
|
*
|
|
* Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*
|
|
* Fixes:
|
|
* Vitaly E. Lavrov RTA_OK arithmetics was wrong.
|
|
*/
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/module.h>
|
|
#include <linux/types.h>
|
|
#include <linux/socket.h>
|
|
#include <linux/kernel.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 <linux/security.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/if_addr.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>
|
|
#include <net/fib_rules.h>
|
|
#include <net/rtnetlink.h>
|
|
|
|
struct rtnl_link
|
|
{
|
|
rtnl_doit_func doit;
|
|
rtnl_dumpit_func dumpit;
|
|
};
|
|
|
|
static DEFINE_MUTEX(rtnl_mutex);
|
|
static struct sock *rtnl;
|
|
|
|
void rtnl_lock(void)
|
|
{
|
|
mutex_lock(&rtnl_mutex);
|
|
}
|
|
|
|
void __rtnl_unlock(void)
|
|
{
|
|
mutex_unlock(&rtnl_mutex);
|
|
}
|
|
|
|
void rtnl_unlock(void)
|
|
{
|
|
mutex_unlock(&rtnl_mutex);
|
|
if (rtnl && rtnl->sk_receive_queue.qlen)
|
|
rtnl->sk_data_ready(rtnl, 0);
|
|
netdev_run_todo();
|
|
}
|
|
|
|
int rtnl_trylock(void)
|
|
{
|
|
return mutex_trylock(&rtnl_mutex);
|
|
}
|
|
|
|
int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static struct rtnl_link *rtnl_msg_handlers[NPROTO];
|
|
|
|
static inline int rtm_msgindex(int msgtype)
|
|
{
|
|
int msgindex = msgtype - RTM_BASE;
|
|
|
|
/*
|
|
* msgindex < 0 implies someone tried to register a netlink
|
|
* control code. msgindex >= RTM_NR_MSGTYPES may indicate that
|
|
* the message type has not been added to linux/rtnetlink.h
|
|
*/
|
|
BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES);
|
|
|
|
return msgindex;
|
|
}
|
|
|
|
static rtnl_doit_func rtnl_get_doit(int protocol, int msgindex)
|
|
{
|
|
struct rtnl_link *tab;
|
|
|
|
tab = rtnl_msg_handlers[protocol];
|
|
if (tab == NULL || tab[msgindex].doit == NULL)
|
|
tab = rtnl_msg_handlers[PF_UNSPEC];
|
|
|
|
return tab ? tab[msgindex].doit : NULL;
|
|
}
|
|
|
|
static rtnl_dumpit_func rtnl_get_dumpit(int protocol, int msgindex)
|
|
{
|
|
struct rtnl_link *tab;
|
|
|
|
tab = rtnl_msg_handlers[protocol];
|
|
if (tab == NULL || tab[msgindex].dumpit == NULL)
|
|
tab = rtnl_msg_handlers[PF_UNSPEC];
|
|
|
|
return tab ? tab[msgindex].dumpit : NULL;
|
|
}
|
|
|
|
/**
|
|
* __rtnl_register - Register a rtnetlink message type
|
|
* @protocol: Protocol family or PF_UNSPEC
|
|
* @msgtype: rtnetlink message type
|
|
* @doit: Function pointer called for each request message
|
|
* @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message
|
|
*
|
|
* Registers the specified function pointers (at least one of them has
|
|
* to be non-NULL) to be called whenever a request message for the
|
|
* specified protocol family and message type is received.
|
|
*
|
|
* The special protocol family PF_UNSPEC may be used to define fallback
|
|
* function pointers for the case when no entry for the specific protocol
|
|
* family exists.
|
|
*
|
|
* Returns 0 on success or a negative error code.
|
|
*/
|
|
int __rtnl_register(int protocol, int msgtype,
|
|
rtnl_doit_func doit, rtnl_dumpit_func dumpit)
|
|
{
|
|
struct rtnl_link *tab;
|
|
int msgindex;
|
|
|
|
BUG_ON(protocol < 0 || protocol >= NPROTO);
|
|
msgindex = rtm_msgindex(msgtype);
|
|
|
|
tab = rtnl_msg_handlers[protocol];
|
|
if (tab == NULL) {
|
|
tab = kcalloc(RTM_NR_MSGTYPES, sizeof(*tab), GFP_KERNEL);
|
|
if (tab == NULL)
|
|
return -ENOBUFS;
|
|
|
|
rtnl_msg_handlers[protocol] = tab;
|
|
}
|
|
|
|
if (doit)
|
|
tab[msgindex].doit = doit;
|
|
|
|
if (dumpit)
|
|
tab[msgindex].dumpit = dumpit;
|
|
|
|
return 0;
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(__rtnl_register);
|
|
|
|
/**
|
|
* rtnl_register - Register a rtnetlink message type
|
|
*
|
|
* Identical to __rtnl_register() but panics on failure. This is useful
|
|
* as failure of this function is very unlikely, it can only happen due
|
|
* to lack of memory when allocating the chain to store all message
|
|
* handlers for a protocol. Meant for use in init functions where lack
|
|
* of memory implies no sense in continueing.
|
|
*/
|
|
void rtnl_register(int protocol, int msgtype,
|
|
rtnl_doit_func doit, rtnl_dumpit_func dumpit)
|
|
{
|
|
if (__rtnl_register(protocol, msgtype, doit, dumpit) < 0)
|
|
panic("Unable to register rtnetlink message handler, "
|
|
"protocol = %d, message type = %d\n",
|
|
protocol, msgtype);
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtnl_register);
|
|
|
|
/**
|
|
* rtnl_unregister - Unregister a rtnetlink message type
|
|
* @protocol: Protocol family or PF_UNSPEC
|
|
* @msgtype: rtnetlink message type
|
|
*
|
|
* Returns 0 on success or a negative error code.
|
|
*/
|
|
int rtnl_unregister(int protocol, int msgtype)
|
|
{
|
|
int msgindex;
|
|
|
|
BUG_ON(protocol < 0 || protocol >= NPROTO);
|
|
msgindex = rtm_msgindex(msgtype);
|
|
|
|
if (rtnl_msg_handlers[protocol] == NULL)
|
|
return -ENOENT;
|
|
|
|
rtnl_msg_handlers[protocol][msgindex].doit = NULL;
|
|
rtnl_msg_handlers[protocol][msgindex].dumpit = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtnl_unregister);
|
|
|
|
/**
|
|
* rtnl_unregister_all - Unregister all rtnetlink message type of a protocol
|
|
* @protocol : Protocol family or PF_UNSPEC
|
|
*
|
|
* Identical to calling rtnl_unregster() for all registered message types
|
|
* of a certain protocol family.
|
|
*/
|
|
void rtnl_unregister_all(int protocol)
|
|
{
|
|
BUG_ON(protocol < 0 || protocol >= NPROTO);
|
|
|
|
kfree(rtnl_msg_handlers[protocol]);
|
|
rtnl_msg_handlers[protocol] = NULL;
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtnl_unregister_all);
|
|
|
|
static const int rtm_min[RTM_NR_FAMILIES] =
|
|
{
|
|
[RTM_FAM(RTM_NEWLINK)] = NLMSG_LENGTH(sizeof(struct ifinfomsg)),
|
|
[RTM_FAM(RTM_NEWADDR)] = NLMSG_LENGTH(sizeof(struct ifaddrmsg)),
|
|
[RTM_FAM(RTM_NEWROUTE)] = NLMSG_LENGTH(sizeof(struct rtmsg)),
|
|
[RTM_FAM(RTM_NEWRULE)] = NLMSG_LENGTH(sizeof(struct fib_rule_hdr)),
|
|
[RTM_FAM(RTM_NEWQDISC)] = NLMSG_LENGTH(sizeof(struct tcmsg)),
|
|
[RTM_FAM(RTM_NEWTCLASS)] = NLMSG_LENGTH(sizeof(struct tcmsg)),
|
|
[RTM_FAM(RTM_NEWTFILTER)] = NLMSG_LENGTH(sizeof(struct tcmsg)),
|
|
[RTM_FAM(RTM_NEWACTION)] = NLMSG_LENGTH(sizeof(struct tcamsg)),
|
|
[RTM_FAM(RTM_GETMULTICAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
|
|
[RTM_FAM(RTM_GETANYCAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)),
|
|
};
|
|
|
|
static const int rta_max[RTM_NR_FAMILIES] =
|
|
{
|
|
[RTM_FAM(RTM_NEWLINK)] = IFLA_MAX,
|
|
[RTM_FAM(RTM_NEWADDR)] = IFA_MAX,
|
|
[RTM_FAM(RTM_NEWROUTE)] = RTA_MAX,
|
|
[RTM_FAM(RTM_NEWRULE)] = FRA_MAX,
|
|
[RTM_FAM(RTM_NEWQDISC)] = TCA_MAX,
|
|
[RTM_FAM(RTM_NEWTCLASS)] = TCA_MAX,
|
|
[RTM_FAM(RTM_NEWTFILTER)] = TCA_MAX,
|
|
[RTM_FAM(RTM_NEWACTION)] = TCAA_MAX,
|
|
};
|
|
|
|
void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
|
|
{
|
|
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);
|
|
memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size);
|
|
}
|
|
|
|
size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size)
|
|
{
|
|
size_t ret = RTA_PAYLOAD(rta);
|
|
char *src = RTA_DATA(rta);
|
|
|
|
if (ret > 0 && src[ret - 1] == '\0')
|
|
ret--;
|
|
if (size > 0) {
|
|
size_t len = (ret >= size) ? size - 1 : ret;
|
|
memset(dest, 0, size);
|
|
memcpy(dest, src, len);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int rtnetlink_send(struct sk_buff *skb, u32 pid, unsigned group, int echo)
|
|
{
|
|
int err = 0;
|
|
|
|
NETLINK_CB(skb).dst_group = 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;
|
|
}
|
|
|
|
int rtnl_unicast(struct sk_buff *skb, u32 pid)
|
|
{
|
|
return nlmsg_unicast(rtnl, skb, pid);
|
|
}
|
|
|
|
int rtnl_notify(struct sk_buff *skb, u32 pid, u32 group,
|
|
struct nlmsghdr *nlh, gfp_t flags)
|
|
{
|
|
int report = 0;
|
|
|
|
if (nlh)
|
|
report = nlmsg_report(nlh);
|
|
|
|
return nlmsg_notify(rtnl, skb, pid, group, report, flags);
|
|
}
|
|
|
|
void rtnl_set_sk_err(u32 group, int error)
|
|
{
|
|
netlink_set_err(rtnl, 0, group, error);
|
|
}
|
|
|
|
int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics)
|
|
{
|
|
struct nlattr *mx;
|
|
int i, valid = 0;
|
|
|
|
mx = nla_nest_start(skb, RTA_METRICS);
|
|
if (mx == NULL)
|
|
return -ENOBUFS;
|
|
|
|
for (i = 0; i < RTAX_MAX; i++) {
|
|
if (metrics[i]) {
|
|
valid++;
|
|
NLA_PUT_U32(skb, i+1, metrics[i]);
|
|
}
|
|
}
|
|
|
|
if (!valid) {
|
|
nla_nest_cancel(skb, mx);
|
|
return 0;
|
|
}
|
|
|
|
return nla_nest_end(skb, mx);
|
|
|
|
nla_put_failure:
|
|
return nla_nest_cancel(skb, mx);
|
|
}
|
|
|
|
int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id,
|
|
u32 ts, u32 tsage, long expires, u32 error)
|
|
{
|
|
struct rta_cacheinfo ci = {
|
|
.rta_lastuse = jiffies_to_clock_t(jiffies - dst->lastuse),
|
|
.rta_used = dst->__use,
|
|
.rta_clntref = atomic_read(&(dst->__refcnt)),
|
|
.rta_error = error,
|
|
.rta_id = id,
|
|
.rta_ts = ts,
|
|
.rta_tsage = tsage,
|
|
};
|
|
|
|
if (expires)
|
|
ci.rta_expires = jiffies_to_clock_t(expires);
|
|
|
|
return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci);
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo);
|
|
|
|
static void set_operstate(struct net_device *dev, unsigned char transition)
|
|
{
|
|
unsigned char operstate = dev->operstate;
|
|
|
|
switch(transition) {
|
|
case IF_OPER_UP:
|
|
if ((operstate == IF_OPER_DORMANT ||
|
|
operstate == IF_OPER_UNKNOWN) &&
|
|
!netif_dormant(dev))
|
|
operstate = IF_OPER_UP;
|
|
break;
|
|
|
|
case IF_OPER_DORMANT:
|
|
if (operstate == IF_OPER_UP ||
|
|
operstate == IF_OPER_UNKNOWN)
|
|
operstate = IF_OPER_DORMANT;
|
|
break;
|
|
}
|
|
|
|
if (dev->operstate != operstate) {
|
|
write_lock_bh(&dev_base_lock);
|
|
dev->operstate = operstate;
|
|
write_unlock_bh(&dev_base_lock);
|
|
netdev_state_change(dev);
|
|
}
|
|
}
|
|
|
|
static void copy_rtnl_link_stats(struct rtnl_link_stats *a,
|
|
struct net_device_stats *b)
|
|
{
|
|
a->rx_packets = b->rx_packets;
|
|
a->tx_packets = b->tx_packets;
|
|
a->rx_bytes = b->rx_bytes;
|
|
a->tx_bytes = b->tx_bytes;
|
|
a->rx_errors = b->rx_errors;
|
|
a->tx_errors = b->tx_errors;
|
|
a->rx_dropped = b->rx_dropped;
|
|
a->tx_dropped = b->tx_dropped;
|
|
|
|
a->multicast = b->multicast;
|
|
a->collisions = b->collisions;
|
|
|
|
a->rx_length_errors = b->rx_length_errors;
|
|
a->rx_over_errors = b->rx_over_errors;
|
|
a->rx_crc_errors = b->rx_crc_errors;
|
|
a->rx_frame_errors = b->rx_frame_errors;
|
|
a->rx_fifo_errors = b->rx_fifo_errors;
|
|
a->rx_missed_errors = b->rx_missed_errors;
|
|
|
|
a->tx_aborted_errors = b->tx_aborted_errors;
|
|
a->tx_carrier_errors = b->tx_carrier_errors;
|
|
a->tx_fifo_errors = b->tx_fifo_errors;
|
|
a->tx_heartbeat_errors = b->tx_heartbeat_errors;
|
|
a->tx_window_errors = b->tx_window_errors;
|
|
|
|
a->rx_compressed = b->rx_compressed;
|
|
a->tx_compressed = b->tx_compressed;
|
|
};
|
|
|
|
static inline size_t if_nlmsg_size(int iwbuflen)
|
|
{
|
|
return NLMSG_ALIGN(sizeof(struct ifinfomsg))
|
|
+ nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */
|
|
+ nla_total_size(IFNAMSIZ) /* IFLA_QDISC */
|
|
+ nla_total_size(sizeof(struct rtnl_link_ifmap))
|
|
+ nla_total_size(sizeof(struct rtnl_link_stats))
|
|
+ nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */
|
|
+ nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */
|
|
+ nla_total_size(4) /* IFLA_TXQLEN */
|
|
+ nla_total_size(4) /* IFLA_WEIGHT */
|
|
+ nla_total_size(4) /* IFLA_MTU */
|
|
+ nla_total_size(4) /* IFLA_LINK */
|
|
+ nla_total_size(4) /* IFLA_MASTER */
|
|
+ nla_total_size(1) /* IFLA_OPERSTATE */
|
|
+ nla_total_size(1) /* IFLA_LINKMODE */
|
|
+ nla_total_size(iwbuflen);
|
|
}
|
|
|
|
static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
|
|
void *iwbuf, int iwbuflen, int type, u32 pid,
|
|
u32 seq, u32 change, unsigned int flags)
|
|
{
|
|
struct ifinfomsg *ifm;
|
|
struct nlmsghdr *nlh;
|
|
|
|
nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags);
|
|
if (nlh == NULL)
|
|
return -EMSGSIZE;
|
|
|
|
ifm = nlmsg_data(nlh);
|
|
ifm->ifi_family = AF_UNSPEC;
|
|
ifm->__ifi_pad = 0;
|
|
ifm->ifi_type = dev->type;
|
|
ifm->ifi_index = dev->ifindex;
|
|
ifm->ifi_flags = dev_get_flags(dev);
|
|
ifm->ifi_change = change;
|
|
|
|
NLA_PUT_STRING(skb, IFLA_IFNAME, dev->name);
|
|
NLA_PUT_U32(skb, IFLA_TXQLEN, dev->tx_queue_len);
|
|
NLA_PUT_U32(skb, IFLA_WEIGHT, dev->weight);
|
|
NLA_PUT_U8(skb, IFLA_OPERSTATE,
|
|
netif_running(dev) ? dev->operstate : IF_OPER_DOWN);
|
|
NLA_PUT_U8(skb, IFLA_LINKMODE, dev->link_mode);
|
|
NLA_PUT_U32(skb, IFLA_MTU, dev->mtu);
|
|
|
|
if (dev->ifindex != dev->iflink)
|
|
NLA_PUT_U32(skb, IFLA_LINK, dev->iflink);
|
|
|
|
if (dev->master)
|
|
NLA_PUT_U32(skb, IFLA_MASTER, dev->master->ifindex);
|
|
|
|
if (dev->qdisc_sleeping)
|
|
NLA_PUT_STRING(skb, IFLA_QDISC, dev->qdisc_sleeping->ops->id);
|
|
|
|
if (1) {
|
|
struct rtnl_link_ifmap map = {
|
|
.mem_start = dev->mem_start,
|
|
.mem_end = dev->mem_end,
|
|
.base_addr = dev->base_addr,
|
|
.irq = dev->irq,
|
|
.dma = dev->dma,
|
|
.port = dev->if_port,
|
|
};
|
|
NLA_PUT(skb, IFLA_MAP, sizeof(map), &map);
|
|
}
|
|
|
|
if (dev->addr_len) {
|
|
NLA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr);
|
|
NLA_PUT(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast);
|
|
}
|
|
|
|
if (dev->get_stats) {
|
|
struct net_device_stats *stats = dev->get_stats(dev);
|
|
if (stats) {
|
|
struct nlattr *attr;
|
|
|
|
attr = nla_reserve(skb, IFLA_STATS,
|
|
sizeof(struct rtnl_link_stats));
|
|
if (attr == NULL)
|
|
goto nla_put_failure;
|
|
|
|
copy_rtnl_link_stats(nla_data(attr), stats);
|
|
}
|
|
}
|
|
|
|
if (iwbuf)
|
|
NLA_PUT(skb, IFLA_WIRELESS, iwbuflen, iwbuf);
|
|
|
|
return nlmsg_end(skb, nlh);
|
|
|
|
nla_put_failure:
|
|
nlmsg_cancel(skb, nlh);
|
|
return -EMSGSIZE;
|
|
}
|
|
|
|
static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb)
|
|
{
|
|
int idx;
|
|
int s_idx = cb->args[0];
|
|
struct net_device *dev;
|
|
|
|
idx = 0;
|
|
for_each_netdev(dev) {
|
|
if (idx < s_idx)
|
|
goto cont;
|
|
if (rtnl_fill_ifinfo(skb, dev, NULL, 0, RTM_NEWLINK,
|
|
NETLINK_CB(cb->skb).pid,
|
|
cb->nlh->nlmsg_seq, 0, NLM_F_MULTI) <= 0)
|
|
break;
|
|
cont:
|
|
idx++;
|
|
}
|
|
cb->args[0] = idx;
|
|
|
|
return skb->len;
|
|
}
|
|
|
|
static struct nla_policy ifla_policy[IFLA_MAX+1] __read_mostly = {
|
|
[IFLA_IFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ-1 },
|
|
[IFLA_MAP] = { .len = sizeof(struct rtnl_link_ifmap) },
|
|
[IFLA_MTU] = { .type = NLA_U32 },
|
|
[IFLA_TXQLEN] = { .type = NLA_U32 },
|
|
[IFLA_WEIGHT] = { .type = NLA_U32 },
|
|
[IFLA_OPERSTATE] = { .type = NLA_U8 },
|
|
[IFLA_LINKMODE] = { .type = NLA_U8 },
|
|
};
|
|
|
|
static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
|
|
{
|
|
struct ifinfomsg *ifm;
|
|
struct net_device *dev;
|
|
int err, send_addr_notify = 0, modified = 0;
|
|
struct nlattr *tb[IFLA_MAX+1];
|
|
char ifname[IFNAMSIZ];
|
|
|
|
err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
|
|
if (err < 0)
|
|
goto errout;
|
|
|
|
if (tb[IFLA_IFNAME])
|
|
nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ);
|
|
else
|
|
ifname[0] = '\0';
|
|
|
|
err = -EINVAL;
|
|
ifm = nlmsg_data(nlh);
|
|
if (ifm->ifi_index >= 0)
|
|
dev = dev_get_by_index(ifm->ifi_index);
|
|
else if (tb[IFLA_IFNAME])
|
|
dev = dev_get_by_name(ifname);
|
|
else
|
|
goto errout;
|
|
|
|
if (dev == NULL) {
|
|
err = -ENODEV;
|
|
goto errout;
|
|
}
|
|
|
|
if (tb[IFLA_ADDRESS] &&
|
|
nla_len(tb[IFLA_ADDRESS]) < dev->addr_len)
|
|
goto errout_dev;
|
|
|
|
if (tb[IFLA_BROADCAST] &&
|
|
nla_len(tb[IFLA_BROADCAST]) < dev->addr_len)
|
|
goto errout_dev;
|
|
|
|
if (tb[IFLA_MAP]) {
|
|
struct rtnl_link_ifmap *u_map;
|
|
struct ifmap k_map;
|
|
|
|
if (!dev->set_config) {
|
|
err = -EOPNOTSUPP;
|
|
goto errout_dev;
|
|
}
|
|
|
|
if (!netif_device_present(dev)) {
|
|
err = -ENODEV;
|
|
goto errout_dev;
|
|
}
|
|
|
|
u_map = nla_data(tb[IFLA_MAP]);
|
|
k_map.mem_start = (unsigned long) u_map->mem_start;
|
|
k_map.mem_end = (unsigned long) u_map->mem_end;
|
|
k_map.base_addr = (unsigned short) u_map->base_addr;
|
|
k_map.irq = (unsigned char) u_map->irq;
|
|
k_map.dma = (unsigned char) u_map->dma;
|
|
k_map.port = (unsigned char) u_map->port;
|
|
|
|
err = dev->set_config(dev, &k_map);
|
|
if (err < 0)
|
|
goto errout_dev;
|
|
|
|
modified = 1;
|
|
}
|
|
|
|
if (tb[IFLA_ADDRESS]) {
|
|
struct sockaddr *sa;
|
|
int len;
|
|
|
|
if (!dev->set_mac_address) {
|
|
err = -EOPNOTSUPP;
|
|
goto errout_dev;
|
|
}
|
|
|
|
if (!netif_device_present(dev)) {
|
|
err = -ENODEV;
|
|
goto errout_dev;
|
|
}
|
|
|
|
len = sizeof(sa_family_t) + dev->addr_len;
|
|
sa = kmalloc(len, GFP_KERNEL);
|
|
if (!sa) {
|
|
err = -ENOMEM;
|
|
goto errout_dev;
|
|
}
|
|
sa->sa_family = dev->type;
|
|
memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]),
|
|
dev->addr_len);
|
|
err = dev->set_mac_address(dev, sa);
|
|
kfree(sa);
|
|
if (err)
|
|
goto errout_dev;
|
|
send_addr_notify = 1;
|
|
modified = 1;
|
|
}
|
|
|
|
if (tb[IFLA_MTU]) {
|
|
err = dev_set_mtu(dev, nla_get_u32(tb[IFLA_MTU]));
|
|
if (err < 0)
|
|
goto errout_dev;
|
|
modified = 1;
|
|
}
|
|
|
|
/*
|
|
* Interface selected by interface index but interface
|
|
* name provided implies that a name change has been
|
|
* requested.
|
|
*/
|
|
if (ifm->ifi_index >= 0 && ifname[0]) {
|
|
err = dev_change_name(dev, ifname);
|
|
if (err < 0)
|
|
goto errout_dev;
|
|
modified = 1;
|
|
}
|
|
|
|
if (tb[IFLA_BROADCAST]) {
|
|
nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len);
|
|
send_addr_notify = 1;
|
|
}
|
|
|
|
|
|
if (ifm->ifi_flags || ifm->ifi_change) {
|
|
unsigned int flags = ifm->ifi_flags;
|
|
|
|
/* bugwards compatibility: ifi_change == 0 is treated as ~0 */
|
|
if (ifm->ifi_change)
|
|
flags = (flags & ifm->ifi_change) |
|
|
(dev->flags & ~ifm->ifi_change);
|
|
dev_change_flags(dev, flags);
|
|
}
|
|
|
|
if (tb[IFLA_TXQLEN])
|
|
dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]);
|
|
|
|
if (tb[IFLA_WEIGHT])
|
|
dev->weight = nla_get_u32(tb[IFLA_WEIGHT]);
|
|
|
|
if (tb[IFLA_OPERSTATE])
|
|
set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE]));
|
|
|
|
if (tb[IFLA_LINKMODE]) {
|
|
write_lock_bh(&dev_base_lock);
|
|
dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]);
|
|
write_unlock_bh(&dev_base_lock);
|
|
}
|
|
|
|
err = 0;
|
|
|
|
errout_dev:
|
|
if (err < 0 && modified && net_ratelimit())
|
|
printk(KERN_WARNING "A link change request failed with "
|
|
"some changes comitted already. Interface %s may "
|
|
"have been left with an inconsistent configuration, "
|
|
"please check.\n", dev->name);
|
|
|
|
if (send_addr_notify)
|
|
call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
|
|
|
|
dev_put(dev);
|
|
errout:
|
|
return err;
|
|
}
|
|
|
|
static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg)
|
|
{
|
|
struct ifinfomsg *ifm;
|
|
struct nlattr *tb[IFLA_MAX+1];
|
|
struct net_device *dev = NULL;
|
|
struct sk_buff *nskb;
|
|
char *iw_buf = NULL, *iw = NULL;
|
|
int iw_buf_len = 0;
|
|
int err;
|
|
|
|
err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy);
|
|
if (err < 0)
|
|
return err;
|
|
|
|
ifm = nlmsg_data(nlh);
|
|
if (ifm->ifi_index >= 0) {
|
|
dev = dev_get_by_index(ifm->ifi_index);
|
|
if (dev == NULL)
|
|
return -ENODEV;
|
|
} else
|
|
return -EINVAL;
|
|
|
|
nskb = nlmsg_new(if_nlmsg_size(iw_buf_len), GFP_KERNEL);
|
|
if (nskb == NULL) {
|
|
err = -ENOBUFS;
|
|
goto errout;
|
|
}
|
|
|
|
err = rtnl_fill_ifinfo(nskb, dev, iw, iw_buf_len, RTM_NEWLINK,
|
|
NETLINK_CB(skb).pid, nlh->nlmsg_seq, 0, 0);
|
|
if (err < 0) {
|
|
/* -EMSGSIZE implies BUG in if_nlmsg_size */
|
|
WARN_ON(err == -EMSGSIZE);
|
|
kfree_skb(nskb);
|
|
goto errout;
|
|
}
|
|
err = rtnl_unicast(nskb, NETLINK_CB(skb).pid);
|
|
errout:
|
|
kfree(iw_buf);
|
|
dev_put(dev);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb)
|
|
{
|
|
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 (rtnl_msg_handlers[idx] == NULL ||
|
|
rtnl_msg_handlers[idx][type].dumpit == NULL)
|
|
continue;
|
|
if (idx > s_idx)
|
|
memset(&cb->args[0], 0, sizeof(cb->args));
|
|
if (rtnl_msg_handlers[idx][type].dumpit(skb, cb))
|
|
break;
|
|
}
|
|
cb->family = idx;
|
|
|
|
return skb->len;
|
|
}
|
|
|
|
void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change)
|
|
{
|
|
struct sk_buff *skb;
|
|
int err = -ENOBUFS;
|
|
|
|
skb = nlmsg_new(if_nlmsg_size(0), GFP_KERNEL);
|
|
if (skb == NULL)
|
|
goto errout;
|
|
|
|
err = rtnl_fill_ifinfo(skb, dev, NULL, 0, type, 0, 0, change, 0);
|
|
if (err < 0) {
|
|
/* -EMSGSIZE implies BUG in if_nlmsg_size() */
|
|
WARN_ON(err == -EMSGSIZE);
|
|
kfree_skb(skb);
|
|
goto errout;
|
|
}
|
|
err = rtnl_notify(skb, 0, RTNLGRP_LINK, NULL, GFP_KERNEL);
|
|
errout:
|
|
if (err < 0)
|
|
rtnl_set_sk_err(RTNLGRP_LINK, err);
|
|
}
|
|
|
|
/* Protected by RTNL sempahore. */
|
|
static struct rtattr **rta_buf;
|
|
static int rtattr_max;
|
|
|
|
/* Process one rtnetlink message. */
|
|
|
|
static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh)
|
|
{
|
|
rtnl_doit_func doit;
|
|
int sz_idx, kind;
|
|
int min_len;
|
|
int family;
|
|
int type;
|
|
int err;
|
|
|
|
type = nlh->nlmsg_type;
|
|
if (type > RTM_MAX)
|
|
return -EOPNOTSUPP;
|
|
|
|
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)
|
|
return -EAFNOSUPPORT;
|
|
|
|
sz_idx = type>>2;
|
|
kind = type&3;
|
|
|
|
if (kind != 2 && security_netlink_recv(skb, CAP_NET_ADMIN))
|
|
return -EPERM;
|
|
|
|
if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) {
|
|
rtnl_dumpit_func dumpit;
|
|
|
|
dumpit = rtnl_get_dumpit(family, type);
|
|
if (dumpit == NULL)
|
|
return -EOPNOTSUPP;
|
|
|
|
__rtnl_unlock();
|
|
err = netlink_dump_start(rtnl, skb, nlh, dumpit, NULL);
|
|
rtnl_lock();
|
|
return err;
|
|
}
|
|
|
|
memset(rta_buf, 0, (rtattr_max * sizeof(struct rtattr *)));
|
|
|
|
min_len = rtm_min[sz_idx];
|
|
if (nlh->nlmsg_len < min_len)
|
|
return -EINVAL;
|
|
|
|
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])
|
|
return -EINVAL;
|
|
rta_buf[flavor-1] = attr;
|
|
}
|
|
attr = RTA_NEXT(attr, attrlen);
|
|
}
|
|
}
|
|
|
|
doit = rtnl_get_doit(family, type);
|
|
if (doit == NULL)
|
|
return -EOPNOTSUPP;
|
|
|
|
return doit(skb, nlh, (void *)&rta_buf[0]);
|
|
}
|
|
|
|
static void rtnetlink_rcv(struct sock *sk, int len)
|
|
{
|
|
unsigned int qlen = 0;
|
|
|
|
do {
|
|
mutex_lock(&rtnl_mutex);
|
|
netlink_run_queue(sk, &qlen, &rtnetlink_rcv_msg);
|
|
mutex_unlock(&rtnl_mutex);
|
|
|
|
netdev_run_todo();
|
|
} while (qlen);
|
|
}
|
|
|
|
static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static struct notifier_block rtnetlink_dev_notifier = {
|
|
.notifier_call = rtnetlink_event,
|
|
};
|
|
|
|
void __init rtnetlink_init(void)
|
|
{
|
|
int i;
|
|
|
|
rtattr_max = 0;
|
|
for (i = 0; i < ARRAY_SIZE(rta_max); i++)
|
|
if (rta_max[i] > rtattr_max)
|
|
rtattr_max = rta_max[i];
|
|
rta_buf = kmalloc(rtattr_max * sizeof(struct rtattr *), GFP_KERNEL);
|
|
if (!rta_buf)
|
|
panic("rtnetlink_init: cannot allocate rta_buf\n");
|
|
|
|
rtnl = netlink_kernel_create(NETLINK_ROUTE, RTNLGRP_MAX, rtnetlink_rcv,
|
|
&rtnl_mutex, THIS_MODULE);
|
|
if (rtnl == NULL)
|
|
panic("rtnetlink_init: cannot initialize rtnetlink\n");
|
|
netlink_set_nonroot(NETLINK_ROUTE, NL_NONROOT_RECV);
|
|
register_netdevice_notifier(&rtnetlink_dev_notifier);
|
|
|
|
rtnl_register(PF_UNSPEC, RTM_GETLINK, rtnl_getlink, rtnl_dump_ifinfo);
|
|
rtnl_register(PF_UNSPEC, RTM_SETLINK, rtnl_setlink, NULL);
|
|
|
|
rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all);
|
|
rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all);
|
|
}
|
|
|
|
EXPORT_SYMBOL(__rta_fill);
|
|
EXPORT_SYMBOL(rtattr_strlcpy);
|
|
EXPORT_SYMBOL(rtattr_parse);
|
|
EXPORT_SYMBOL(rtnetlink_put_metrics);
|
|
EXPORT_SYMBOL(rtnl_lock);
|
|
EXPORT_SYMBOL(rtnl_trylock);
|
|
EXPORT_SYMBOL(rtnl_unlock);
|
|
EXPORT_SYMBOL(rtnl_unicast);
|
|
EXPORT_SYMBOL(rtnl_notify);
|
|
EXPORT_SYMBOL(rtnl_set_sk_err);
|