rtnetlink.c revision 1d00a4eb42bdade33a6ec0961cada93577a66ae6
1/* 2 * INET An implementation of the TCP/IP protocol suite for the LINUX 3 * operating system. INET is implemented using the BSD Socket 4 * interface as the means of communication with the user level. 5 * 6 * Routing netlink socket interface: protocol independent part. 7 * 8 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License 12 * as published by the Free Software Foundation; either version 13 * 2 of the License, or (at your option) any later version. 14 * 15 * Fixes: 16 * Vitaly E. Lavrov RTA_OK arithmetics was wrong. 17 */ 18 19#include <linux/errno.h> 20#include <linux/module.h> 21#include <linux/types.h> 22#include <linux/socket.h> 23#include <linux/kernel.h> 24#include <linux/timer.h> 25#include <linux/string.h> 26#include <linux/sockios.h> 27#include <linux/net.h> 28#include <linux/fcntl.h> 29#include <linux/mm.h> 30#include <linux/slab.h> 31#include <linux/interrupt.h> 32#include <linux/capability.h> 33#include <linux/skbuff.h> 34#include <linux/init.h> 35#include <linux/security.h> 36#include <linux/mutex.h> 37#include <linux/if_addr.h> 38 39#include <asm/uaccess.h> 40#include <asm/system.h> 41#include <asm/string.h> 42 43#include <linux/inet.h> 44#include <linux/netdevice.h> 45#include <net/ip.h> 46#include <net/protocol.h> 47#include <net/arp.h> 48#include <net/route.h> 49#include <net/udp.h> 50#include <net/sock.h> 51#include <net/pkt_sched.h> 52#include <net/fib_rules.h> 53#include <net/rtnetlink.h> 54#ifdef CONFIG_NET_WIRELESS_RTNETLINK 55#include <linux/wireless.h> 56#include <net/iw_handler.h> 57#endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 58 59struct rtnl_link 60{ 61 rtnl_doit_func doit; 62 rtnl_dumpit_func dumpit; 63}; 64 65static DEFINE_MUTEX(rtnl_mutex); 66static struct sock *rtnl; 67 68void rtnl_lock(void) 69{ 70 mutex_lock(&rtnl_mutex); 71} 72 73void __rtnl_unlock(void) 74{ 75 mutex_unlock(&rtnl_mutex); 76} 77 78void rtnl_unlock(void) 79{ 80 mutex_unlock(&rtnl_mutex); 81 if (rtnl && rtnl->sk_receive_queue.qlen) 82 rtnl->sk_data_ready(rtnl, 0); 83 netdev_run_todo(); 84} 85 86int rtnl_trylock(void) 87{ 88 return mutex_trylock(&rtnl_mutex); 89} 90 91int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len) 92{ 93 memset(tb, 0, sizeof(struct rtattr*)*maxattr); 94 95 while (RTA_OK(rta, len)) { 96 unsigned flavor = rta->rta_type; 97 if (flavor && flavor <= maxattr) 98 tb[flavor-1] = rta; 99 rta = RTA_NEXT(rta, len); 100 } 101 return 0; 102} 103 104struct rtnl_link *rtnl_msg_handlers[NPROTO]; 105 106static inline int rtm_msgindex(int msgtype) 107{ 108 int msgindex = msgtype - RTM_BASE; 109 110 /* 111 * msgindex < 0 implies someone tried to register a netlink 112 * control code. msgindex >= RTM_NR_MSGTYPES may indicate that 113 * the message type has not been added to linux/rtnetlink.h 114 */ 115 BUG_ON(msgindex < 0 || msgindex >= RTM_NR_MSGTYPES); 116 117 return msgindex; 118} 119 120static rtnl_doit_func rtnl_get_doit(int protocol, int msgindex) 121{ 122 struct rtnl_link *tab; 123 124 tab = rtnl_msg_handlers[protocol]; 125 if (tab == NULL || tab[msgindex].doit == NULL) 126 tab = rtnl_msg_handlers[PF_UNSPEC]; 127 128 return tab ? tab[msgindex].doit : NULL; 129} 130 131static rtnl_dumpit_func rtnl_get_dumpit(int protocol, int msgindex) 132{ 133 struct rtnl_link *tab; 134 135 tab = rtnl_msg_handlers[protocol]; 136 if (tab == NULL || tab[msgindex].dumpit == NULL) 137 tab = rtnl_msg_handlers[PF_UNSPEC]; 138 139 return tab ? tab[msgindex].dumpit : NULL; 140} 141 142/** 143 * __rtnl_register - Register a rtnetlink message type 144 * @protocol: Protocol family or PF_UNSPEC 145 * @msgtype: rtnetlink message type 146 * @doit: Function pointer called for each request message 147 * @dumpit: Function pointer called for each dump request (NLM_F_DUMP) message 148 * 149 * Registers the specified function pointers (at least one of them has 150 * to be non-NULL) to be called whenever a request message for the 151 * specified protocol family and message type is received. 152 * 153 * The special protocol family PF_UNSPEC may be used to define fallback 154 * function pointers for the case when no entry for the specific protocol 155 * family exists. 156 * 157 * Returns 0 on success or a negative error code. 158 */ 159int __rtnl_register(int protocol, int msgtype, 160 rtnl_doit_func doit, rtnl_dumpit_func dumpit) 161{ 162 struct rtnl_link *tab; 163 int msgindex; 164 165 BUG_ON(protocol < 0 || protocol >= NPROTO); 166 msgindex = rtm_msgindex(msgtype); 167 168 tab = rtnl_msg_handlers[protocol]; 169 if (tab == NULL) { 170 tab = kcalloc(RTM_NR_MSGTYPES, sizeof(*tab), GFP_KERNEL); 171 if (tab == NULL) 172 return -ENOBUFS; 173 174 rtnl_msg_handlers[protocol] = tab; 175 } 176 177 if (doit) 178 tab[msgindex].doit = doit; 179 180 if (dumpit) 181 tab[msgindex].dumpit = dumpit; 182 183 return 0; 184} 185 186EXPORT_SYMBOL_GPL(__rtnl_register); 187 188/** 189 * rtnl_register - Register a rtnetlink message type 190 * 191 * Identical to __rtnl_register() but panics on failure. This is useful 192 * as failure of this function is very unlikely, it can only happen due 193 * to lack of memory when allocating the chain to store all message 194 * handlers for a protocol. Meant for use in init functions where lack 195 * of memory implies no sense in continueing. 196 */ 197void rtnl_register(int protocol, int msgtype, 198 rtnl_doit_func doit, rtnl_dumpit_func dumpit) 199{ 200 if (__rtnl_register(protocol, msgtype, doit, dumpit) < 0) 201 panic("Unable to register rtnetlink message handler, " 202 "protocol = %d, message type = %d\n", 203 protocol, msgtype); 204} 205 206EXPORT_SYMBOL_GPL(rtnl_register); 207 208/** 209 * rtnl_unregister - Unregister a rtnetlink message type 210 * @protocol: Protocol family or PF_UNSPEC 211 * @msgtype: rtnetlink message type 212 * 213 * Returns 0 on success or a negative error code. 214 */ 215int rtnl_unregister(int protocol, int msgtype) 216{ 217 int msgindex; 218 219 BUG_ON(protocol < 0 || protocol >= NPROTO); 220 msgindex = rtm_msgindex(msgtype); 221 222 if (rtnl_msg_handlers[protocol] == NULL) 223 return -ENOENT; 224 225 rtnl_msg_handlers[protocol][msgindex].doit = NULL; 226 rtnl_msg_handlers[protocol][msgindex].dumpit = NULL; 227 228 return 0; 229} 230 231EXPORT_SYMBOL_GPL(rtnl_unregister); 232 233/** 234 * rtnl_unregister_all - Unregister all rtnetlink message type of a protocol 235 * @protocol : Protocol family or PF_UNSPEC 236 * 237 * Identical to calling rtnl_unregster() for all registered message types 238 * of a certain protocol family. 239 */ 240void rtnl_unregister_all(int protocol) 241{ 242 BUG_ON(protocol < 0 || protocol >= NPROTO); 243 244 kfree(rtnl_msg_handlers[protocol]); 245 rtnl_msg_handlers[protocol] = NULL; 246} 247 248EXPORT_SYMBOL_GPL(rtnl_unregister_all); 249 250static const int rtm_min[RTM_NR_FAMILIES] = 251{ 252 [RTM_FAM(RTM_NEWLINK)] = NLMSG_LENGTH(sizeof(struct ifinfomsg)), 253 [RTM_FAM(RTM_NEWADDR)] = NLMSG_LENGTH(sizeof(struct ifaddrmsg)), 254 [RTM_FAM(RTM_NEWROUTE)] = NLMSG_LENGTH(sizeof(struct rtmsg)), 255 [RTM_FAM(RTM_NEWRULE)] = NLMSG_LENGTH(sizeof(struct fib_rule_hdr)), 256 [RTM_FAM(RTM_NEWQDISC)] = NLMSG_LENGTH(sizeof(struct tcmsg)), 257 [RTM_FAM(RTM_NEWTCLASS)] = NLMSG_LENGTH(sizeof(struct tcmsg)), 258 [RTM_FAM(RTM_NEWTFILTER)] = NLMSG_LENGTH(sizeof(struct tcmsg)), 259 [RTM_FAM(RTM_NEWACTION)] = NLMSG_LENGTH(sizeof(struct tcamsg)), 260 [RTM_FAM(RTM_GETMULTICAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)), 261 [RTM_FAM(RTM_GETANYCAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)), 262}; 263 264static const int rta_max[RTM_NR_FAMILIES] = 265{ 266 [RTM_FAM(RTM_NEWLINK)] = IFLA_MAX, 267 [RTM_FAM(RTM_NEWADDR)] = IFA_MAX, 268 [RTM_FAM(RTM_NEWROUTE)] = RTA_MAX, 269 [RTM_FAM(RTM_NEWRULE)] = FRA_MAX, 270 [RTM_FAM(RTM_NEWQDISC)] = TCA_MAX, 271 [RTM_FAM(RTM_NEWTCLASS)] = TCA_MAX, 272 [RTM_FAM(RTM_NEWTFILTER)] = TCA_MAX, 273 [RTM_FAM(RTM_NEWACTION)] = TCAA_MAX, 274}; 275 276void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data) 277{ 278 struct rtattr *rta; 279 int size = RTA_LENGTH(attrlen); 280 281 rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size)); 282 rta->rta_type = attrtype; 283 rta->rta_len = size; 284 memcpy(RTA_DATA(rta), data, attrlen); 285 memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size); 286} 287 288size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size) 289{ 290 size_t ret = RTA_PAYLOAD(rta); 291 char *src = RTA_DATA(rta); 292 293 if (ret > 0 && src[ret - 1] == '\0') 294 ret--; 295 if (size > 0) { 296 size_t len = (ret >= size) ? size - 1 : ret; 297 memset(dest, 0, size); 298 memcpy(dest, src, len); 299 } 300 return ret; 301} 302 303int rtnetlink_send(struct sk_buff *skb, u32 pid, unsigned group, int echo) 304{ 305 int err = 0; 306 307 NETLINK_CB(skb).dst_group = group; 308 if (echo) 309 atomic_inc(&skb->users); 310 netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL); 311 if (echo) 312 err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT); 313 return err; 314} 315 316int rtnl_unicast(struct sk_buff *skb, u32 pid) 317{ 318 return nlmsg_unicast(rtnl, skb, pid); 319} 320 321int rtnl_notify(struct sk_buff *skb, u32 pid, u32 group, 322 struct nlmsghdr *nlh, gfp_t flags) 323{ 324 int report = 0; 325 326 if (nlh) 327 report = nlmsg_report(nlh); 328 329 return nlmsg_notify(rtnl, skb, pid, group, report, flags); 330} 331 332void rtnl_set_sk_err(u32 group, int error) 333{ 334 netlink_set_err(rtnl, 0, group, error); 335} 336 337int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics) 338{ 339 struct nlattr *mx; 340 int i, valid = 0; 341 342 mx = nla_nest_start(skb, RTA_METRICS); 343 if (mx == NULL) 344 return -ENOBUFS; 345 346 for (i = 0; i < RTAX_MAX; i++) { 347 if (metrics[i]) { 348 valid++; 349 NLA_PUT_U32(skb, i+1, metrics[i]); 350 } 351 } 352 353 if (!valid) { 354 nla_nest_cancel(skb, mx); 355 return 0; 356 } 357 358 return nla_nest_end(skb, mx); 359 360nla_put_failure: 361 return nla_nest_cancel(skb, mx); 362} 363 364int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id, 365 u32 ts, u32 tsage, long expires, u32 error) 366{ 367 struct rta_cacheinfo ci = { 368 .rta_lastuse = jiffies_to_clock_t(jiffies - dst->lastuse), 369 .rta_used = dst->__use, 370 .rta_clntref = atomic_read(&(dst->__refcnt)), 371 .rta_error = error, 372 .rta_id = id, 373 .rta_ts = ts, 374 .rta_tsage = tsage, 375 }; 376 377 if (expires) 378 ci.rta_expires = jiffies_to_clock_t(expires); 379 380 return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci); 381} 382 383EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo); 384 385static void set_operstate(struct net_device *dev, unsigned char transition) 386{ 387 unsigned char operstate = dev->operstate; 388 389 switch(transition) { 390 case IF_OPER_UP: 391 if ((operstate == IF_OPER_DORMANT || 392 operstate == IF_OPER_UNKNOWN) && 393 !netif_dormant(dev)) 394 operstate = IF_OPER_UP; 395 break; 396 397 case IF_OPER_DORMANT: 398 if (operstate == IF_OPER_UP || 399 operstate == IF_OPER_UNKNOWN) 400 operstate = IF_OPER_DORMANT; 401 break; 402 }; 403 404 if (dev->operstate != operstate) { 405 write_lock_bh(&dev_base_lock); 406 dev->operstate = operstate; 407 write_unlock_bh(&dev_base_lock); 408 netdev_state_change(dev); 409 } 410} 411 412static void copy_rtnl_link_stats(struct rtnl_link_stats *a, 413 struct net_device_stats *b) 414{ 415 a->rx_packets = b->rx_packets; 416 a->tx_packets = b->tx_packets; 417 a->rx_bytes = b->rx_bytes; 418 a->tx_bytes = b->tx_bytes; 419 a->rx_errors = b->rx_errors; 420 a->tx_errors = b->tx_errors; 421 a->rx_dropped = b->rx_dropped; 422 a->tx_dropped = b->tx_dropped; 423 424 a->multicast = b->multicast; 425 a->collisions = b->collisions; 426 427 a->rx_length_errors = b->rx_length_errors; 428 a->rx_over_errors = b->rx_over_errors; 429 a->rx_crc_errors = b->rx_crc_errors; 430 a->rx_frame_errors = b->rx_frame_errors; 431 a->rx_fifo_errors = b->rx_fifo_errors; 432 a->rx_missed_errors = b->rx_missed_errors; 433 434 a->tx_aborted_errors = b->tx_aborted_errors; 435 a->tx_carrier_errors = b->tx_carrier_errors; 436 a->tx_fifo_errors = b->tx_fifo_errors; 437 a->tx_heartbeat_errors = b->tx_heartbeat_errors; 438 a->tx_window_errors = b->tx_window_errors; 439 440 a->rx_compressed = b->rx_compressed; 441 a->tx_compressed = b->tx_compressed; 442}; 443 444static inline size_t if_nlmsg_size(int iwbuflen) 445{ 446 return NLMSG_ALIGN(sizeof(struct ifinfomsg)) 447 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */ 448 + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */ 449 + nla_total_size(sizeof(struct rtnl_link_ifmap)) 450 + nla_total_size(sizeof(struct rtnl_link_stats)) 451 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */ 452 + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */ 453 + nla_total_size(4) /* IFLA_TXQLEN */ 454 + nla_total_size(4) /* IFLA_WEIGHT */ 455 + nla_total_size(4) /* IFLA_MTU */ 456 + nla_total_size(4) /* IFLA_LINK */ 457 + nla_total_size(4) /* IFLA_MASTER */ 458 + nla_total_size(1) /* IFLA_OPERSTATE */ 459 + nla_total_size(1) /* IFLA_LINKMODE */ 460 + nla_total_size(iwbuflen); 461} 462 463static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev, 464 void *iwbuf, int iwbuflen, int type, u32 pid, 465 u32 seq, u32 change, unsigned int flags) 466{ 467 struct ifinfomsg *ifm; 468 struct nlmsghdr *nlh; 469 470 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags); 471 if (nlh == NULL) 472 return -EMSGSIZE; 473 474 ifm = nlmsg_data(nlh); 475 ifm->ifi_family = AF_UNSPEC; 476 ifm->__ifi_pad = 0; 477 ifm->ifi_type = dev->type; 478 ifm->ifi_index = dev->ifindex; 479 ifm->ifi_flags = dev_get_flags(dev); 480 ifm->ifi_change = change; 481 482 NLA_PUT_STRING(skb, IFLA_IFNAME, dev->name); 483 NLA_PUT_U32(skb, IFLA_TXQLEN, dev->tx_queue_len); 484 NLA_PUT_U32(skb, IFLA_WEIGHT, dev->weight); 485 NLA_PUT_U8(skb, IFLA_OPERSTATE, 486 netif_running(dev) ? dev->operstate : IF_OPER_DOWN); 487 NLA_PUT_U8(skb, IFLA_LINKMODE, dev->link_mode); 488 NLA_PUT_U32(skb, IFLA_MTU, dev->mtu); 489 490 if (dev->ifindex != dev->iflink) 491 NLA_PUT_U32(skb, IFLA_LINK, dev->iflink); 492 493 if (dev->master) 494 NLA_PUT_U32(skb, IFLA_MASTER, dev->master->ifindex); 495 496 if (dev->qdisc_sleeping) 497 NLA_PUT_STRING(skb, IFLA_QDISC, dev->qdisc_sleeping->ops->id); 498 499 if (1) { 500 struct rtnl_link_ifmap map = { 501 .mem_start = dev->mem_start, 502 .mem_end = dev->mem_end, 503 .base_addr = dev->base_addr, 504 .irq = dev->irq, 505 .dma = dev->dma, 506 .port = dev->if_port, 507 }; 508 NLA_PUT(skb, IFLA_MAP, sizeof(map), &map); 509 } 510 511 if (dev->addr_len) { 512 NLA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr); 513 NLA_PUT(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast); 514 } 515 516 if (dev->get_stats) { 517 struct net_device_stats *stats = dev->get_stats(dev); 518 if (stats) { 519 struct nlattr *attr; 520 521 attr = nla_reserve(skb, IFLA_STATS, 522 sizeof(struct rtnl_link_stats)); 523 if (attr == NULL) 524 goto nla_put_failure; 525 526 copy_rtnl_link_stats(nla_data(attr), stats); 527 } 528 } 529 530 if (iwbuf) 531 NLA_PUT(skb, IFLA_WIRELESS, iwbuflen, iwbuf); 532 533 return nlmsg_end(skb, nlh); 534 535nla_put_failure: 536 nlmsg_cancel(skb, nlh); 537 return -EMSGSIZE; 538} 539 540static int rtnl_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb) 541{ 542 int idx; 543 int s_idx = cb->args[0]; 544 struct net_device *dev; 545 546 read_lock(&dev_base_lock); 547 for (dev=dev_base, idx=0; dev; dev = dev->next, idx++) { 548 if (idx < s_idx) 549 continue; 550 if (rtnl_fill_ifinfo(skb, dev, NULL, 0, RTM_NEWLINK, 551 NETLINK_CB(cb->skb).pid, 552 cb->nlh->nlmsg_seq, 0, NLM_F_MULTI) <= 0) 553 break; 554 } 555 read_unlock(&dev_base_lock); 556 cb->args[0] = idx; 557 558 return skb->len; 559} 560 561static struct nla_policy ifla_policy[IFLA_MAX+1] __read_mostly = { 562 [IFLA_IFNAME] = { .type = NLA_STRING, .len = IFNAMSIZ-1 }, 563 [IFLA_MAP] = { .len = sizeof(struct rtnl_link_ifmap) }, 564 [IFLA_MTU] = { .type = NLA_U32 }, 565 [IFLA_TXQLEN] = { .type = NLA_U32 }, 566 [IFLA_WEIGHT] = { .type = NLA_U32 }, 567 [IFLA_OPERSTATE] = { .type = NLA_U8 }, 568 [IFLA_LINKMODE] = { .type = NLA_U8 }, 569}; 570 571static int rtnl_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 572{ 573 struct ifinfomsg *ifm; 574 struct net_device *dev; 575 int err, send_addr_notify = 0, modified = 0; 576 struct nlattr *tb[IFLA_MAX+1]; 577 char ifname[IFNAMSIZ]; 578 579 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy); 580 if (err < 0) 581 goto errout; 582 583 if (tb[IFLA_IFNAME]) 584 nla_strlcpy(ifname, tb[IFLA_IFNAME], IFNAMSIZ); 585 else 586 ifname[0] = '\0'; 587 588 err = -EINVAL; 589 ifm = nlmsg_data(nlh); 590 if (ifm->ifi_index >= 0) 591 dev = dev_get_by_index(ifm->ifi_index); 592 else if (tb[IFLA_IFNAME]) 593 dev = dev_get_by_name(ifname); 594 else 595 goto errout; 596 597 if (dev == NULL) { 598 err = -ENODEV; 599 goto errout; 600 } 601 602 if (tb[IFLA_ADDRESS] && 603 nla_len(tb[IFLA_ADDRESS]) < dev->addr_len) 604 goto errout_dev; 605 606 if (tb[IFLA_BROADCAST] && 607 nla_len(tb[IFLA_BROADCAST]) < dev->addr_len) 608 goto errout_dev; 609 610 if (tb[IFLA_MAP]) { 611 struct rtnl_link_ifmap *u_map; 612 struct ifmap k_map; 613 614 if (!dev->set_config) { 615 err = -EOPNOTSUPP; 616 goto errout_dev; 617 } 618 619 if (!netif_device_present(dev)) { 620 err = -ENODEV; 621 goto errout_dev; 622 } 623 624 u_map = nla_data(tb[IFLA_MAP]); 625 k_map.mem_start = (unsigned long) u_map->mem_start; 626 k_map.mem_end = (unsigned long) u_map->mem_end; 627 k_map.base_addr = (unsigned short) u_map->base_addr; 628 k_map.irq = (unsigned char) u_map->irq; 629 k_map.dma = (unsigned char) u_map->dma; 630 k_map.port = (unsigned char) u_map->port; 631 632 err = dev->set_config(dev, &k_map); 633 if (err < 0) 634 goto errout_dev; 635 636 modified = 1; 637 } 638 639 if (tb[IFLA_ADDRESS]) { 640 struct sockaddr *sa; 641 int len; 642 643 if (!dev->set_mac_address) { 644 err = -EOPNOTSUPP; 645 goto errout_dev; 646 } 647 648 if (!netif_device_present(dev)) { 649 err = -ENODEV; 650 goto errout_dev; 651 } 652 653 len = sizeof(sa_family_t) + dev->addr_len; 654 sa = kmalloc(len, GFP_KERNEL); 655 if (!sa) { 656 err = -ENOMEM; 657 goto errout_dev; 658 } 659 sa->sa_family = dev->type; 660 memcpy(sa->sa_data, nla_data(tb[IFLA_ADDRESS]), 661 dev->addr_len); 662 err = dev->set_mac_address(dev, sa); 663 kfree(sa); 664 if (err) 665 goto errout_dev; 666 send_addr_notify = 1; 667 modified = 1; 668 } 669 670 if (tb[IFLA_MTU]) { 671 err = dev_set_mtu(dev, nla_get_u32(tb[IFLA_MTU])); 672 if (err < 0) 673 goto errout_dev; 674 modified = 1; 675 } 676 677 /* 678 * Interface selected by interface index but interface 679 * name provided implies that a name change has been 680 * requested. 681 */ 682 if (ifm->ifi_index >= 0 && ifname[0]) { 683 err = dev_change_name(dev, ifname); 684 if (err < 0) 685 goto errout_dev; 686 modified = 1; 687 } 688 689#ifdef CONFIG_NET_WIRELESS_RTNETLINK 690 if (tb[IFLA_WIRELESS]) { 691 /* Call Wireless Extensions. 692 * Various stuff checked in there... */ 693 err = wireless_rtnetlink_set(dev, nla_data(tb[IFLA_WIRELESS]), 694 nla_len(tb[IFLA_WIRELESS])); 695 if (err < 0) 696 goto errout_dev; 697 } 698#endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 699 700 if (tb[IFLA_BROADCAST]) { 701 nla_memcpy(dev->broadcast, tb[IFLA_BROADCAST], dev->addr_len); 702 send_addr_notify = 1; 703 } 704 705 706 if (ifm->ifi_flags) 707 dev_change_flags(dev, ifm->ifi_flags); 708 709 if (tb[IFLA_TXQLEN]) 710 dev->tx_queue_len = nla_get_u32(tb[IFLA_TXQLEN]); 711 712 if (tb[IFLA_WEIGHT]) 713 dev->weight = nla_get_u32(tb[IFLA_WEIGHT]); 714 715 if (tb[IFLA_OPERSTATE]) 716 set_operstate(dev, nla_get_u8(tb[IFLA_OPERSTATE])); 717 718 if (tb[IFLA_LINKMODE]) { 719 write_lock_bh(&dev_base_lock); 720 dev->link_mode = nla_get_u8(tb[IFLA_LINKMODE]); 721 write_unlock_bh(&dev_base_lock); 722 } 723 724 err = 0; 725 726errout_dev: 727 if (err < 0 && modified && net_ratelimit()) 728 printk(KERN_WARNING "A link change request failed with " 729 "some changes comitted already. Interface %s may " 730 "have been left with an inconsistent configuration, " 731 "please check.\n", dev->name); 732 733 if (send_addr_notify) 734 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); 735 736 dev_put(dev); 737errout: 738 return err; 739} 740 741static int rtnl_getlink(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg) 742{ 743 struct ifinfomsg *ifm; 744 struct nlattr *tb[IFLA_MAX+1]; 745 struct net_device *dev = NULL; 746 struct sk_buff *nskb; 747 char *iw_buf = NULL, *iw = NULL; 748 int iw_buf_len = 0; 749 int err; 750 751 err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFLA_MAX, ifla_policy); 752 if (err < 0) 753 return err; 754 755 ifm = nlmsg_data(nlh); 756 if (ifm->ifi_index >= 0) { 757 dev = dev_get_by_index(ifm->ifi_index); 758 if (dev == NULL) 759 return -ENODEV; 760 } else 761 return -EINVAL; 762 763 764#ifdef CONFIG_NET_WIRELESS_RTNETLINK 765 if (tb[IFLA_WIRELESS]) { 766 /* Call Wireless Extensions. We need to know the size before 767 * we can alloc. Various stuff checked in there... */ 768 err = wireless_rtnetlink_get(dev, nla_data(tb[IFLA_WIRELESS]), 769 nla_len(tb[IFLA_WIRELESS]), 770 &iw_buf, &iw_buf_len); 771 if (err < 0) 772 goto errout; 773 774 /* Payload is at an offset in buffer */ 775 iw = iw_buf + IW_EV_POINT_OFF; 776 } 777#endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 778 779 nskb = nlmsg_new(if_nlmsg_size(iw_buf_len), GFP_KERNEL); 780 if (nskb == NULL) { 781 err = -ENOBUFS; 782 goto errout; 783 } 784 785 err = rtnl_fill_ifinfo(nskb, dev, iw, iw_buf_len, RTM_NEWLINK, 786 NETLINK_CB(skb).pid, nlh->nlmsg_seq, 0, 0); 787 if (err < 0) { 788 /* -EMSGSIZE implies BUG in if_nlmsg_size */ 789 WARN_ON(err == -EMSGSIZE); 790 kfree_skb(nskb); 791 goto errout; 792 } 793 err = rtnl_unicast(nskb, NETLINK_CB(skb).pid); 794errout: 795 kfree(iw_buf); 796 dev_put(dev); 797 798 return err; 799} 800 801int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb) 802{ 803 int idx; 804 int s_idx = cb->family; 805 806 if (s_idx == 0) 807 s_idx = 1; 808 for (idx=1; idx<NPROTO; idx++) { 809 int type = cb->nlh->nlmsg_type-RTM_BASE; 810 if (idx < s_idx || idx == PF_PACKET) 811 continue; 812 if (rtnl_msg_handlers[idx] == NULL || 813 rtnl_msg_handlers[idx][type].dumpit == NULL) 814 continue; 815 if (idx > s_idx) 816 memset(&cb->args[0], 0, sizeof(cb->args)); 817 if (rtnl_msg_handlers[idx][type].dumpit(skb, cb)) 818 break; 819 } 820 cb->family = idx; 821 822 return skb->len; 823} 824 825EXPORT_SYMBOL_GPL(rtnl_dump_all); 826 827void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change) 828{ 829 struct sk_buff *skb; 830 int err = -ENOBUFS; 831 832 skb = nlmsg_new(if_nlmsg_size(0), GFP_KERNEL); 833 if (skb == NULL) 834 goto errout; 835 836 err = rtnl_fill_ifinfo(skb, dev, NULL, 0, type, 0, 0, change, 0); 837 if (err < 0) { 838 /* -EMSGSIZE implies BUG in if_nlmsg_size() */ 839 WARN_ON(err == -EMSGSIZE); 840 kfree_skb(skb); 841 goto errout; 842 } 843 err = rtnl_notify(skb, 0, RTNLGRP_LINK, NULL, GFP_KERNEL); 844errout: 845 if (err < 0) 846 rtnl_set_sk_err(RTNLGRP_LINK, err); 847} 848 849/* Protected by RTNL sempahore. */ 850static struct rtattr **rta_buf; 851static int rtattr_max; 852 853/* Process one rtnetlink message. */ 854 855static int rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh) 856{ 857 rtnl_doit_func doit; 858 int sz_idx, kind; 859 int min_len; 860 int family; 861 int type; 862 int err; 863 864 type = nlh->nlmsg_type; 865 if (type > RTM_MAX) 866 return -EINVAL; 867 868 type -= RTM_BASE; 869 870 /* All the messages must have at least 1 byte length */ 871 if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtgenmsg))) 872 return 0; 873 874 family = ((struct rtgenmsg*)NLMSG_DATA(nlh))->rtgen_family; 875 if (family >= NPROTO) 876 return -EAFNOSUPPORT; 877 878 sz_idx = type>>2; 879 kind = type&3; 880 881 if (kind != 2 && security_netlink_recv(skb, CAP_NET_ADMIN)) 882 return -EPERM; 883 884 if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) { 885 rtnl_dumpit_func dumpit; 886 887 dumpit = rtnl_get_dumpit(family, type); 888 if (dumpit == NULL) 889 return -EINVAL; 890 891 err = netlink_dump_start(rtnl, skb, nlh, dumpit, NULL); 892 if (err == 0) 893 err = -EINTR; 894 return err; 895 } 896 897 memset(rta_buf, 0, (rtattr_max * sizeof(struct rtattr *))); 898 899 min_len = rtm_min[sz_idx]; 900 if (nlh->nlmsg_len < min_len) 901 return -EINVAL; 902 903 if (nlh->nlmsg_len > min_len) { 904 int attrlen = nlh->nlmsg_len - NLMSG_ALIGN(min_len); 905 struct rtattr *attr = (void*)nlh + NLMSG_ALIGN(min_len); 906 907 while (RTA_OK(attr, attrlen)) { 908 unsigned flavor = attr->rta_type; 909 if (flavor) { 910 if (flavor > rta_max[sz_idx]) 911 return -EINVAL; 912 rta_buf[flavor-1] = attr; 913 } 914 attr = RTA_NEXT(attr, attrlen); 915 } 916 } 917 918 doit = rtnl_get_doit(family, type); 919 if (doit == NULL) 920 return -EINVAL; 921 922 return doit(skb, nlh, (void *)&rta_buf[0]); 923} 924 925static void rtnetlink_rcv(struct sock *sk, int len) 926{ 927 unsigned int qlen = 0; 928 929 do { 930 mutex_lock(&rtnl_mutex); 931 netlink_run_queue(sk, &qlen, &rtnetlink_rcv_msg); 932 mutex_unlock(&rtnl_mutex); 933 934 netdev_run_todo(); 935 } while (qlen); 936} 937 938static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr) 939{ 940 struct net_device *dev = ptr; 941 switch (event) { 942 case NETDEV_UNREGISTER: 943 rtmsg_ifinfo(RTM_DELLINK, dev, ~0U); 944 break; 945 case NETDEV_REGISTER: 946 rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U); 947 break; 948 case NETDEV_UP: 949 case NETDEV_DOWN: 950 rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING); 951 break; 952 case NETDEV_CHANGE: 953 case NETDEV_GOING_DOWN: 954 break; 955 default: 956 rtmsg_ifinfo(RTM_NEWLINK, dev, 0); 957 break; 958 } 959 return NOTIFY_DONE; 960} 961 962static struct notifier_block rtnetlink_dev_notifier = { 963 .notifier_call = rtnetlink_event, 964}; 965 966void __init rtnetlink_init(void) 967{ 968 int i; 969 970 rtattr_max = 0; 971 for (i = 0; i < ARRAY_SIZE(rta_max); i++) 972 if (rta_max[i] > rtattr_max) 973 rtattr_max = rta_max[i]; 974 rta_buf = kmalloc(rtattr_max * sizeof(struct rtattr *), GFP_KERNEL); 975 if (!rta_buf) 976 panic("rtnetlink_init: cannot allocate rta_buf\n"); 977 978 rtnl = netlink_kernel_create(NETLINK_ROUTE, RTNLGRP_MAX, rtnetlink_rcv, 979 THIS_MODULE); 980 if (rtnl == NULL) 981 panic("rtnetlink_init: cannot initialize rtnetlink\n"); 982 netlink_set_nonroot(NETLINK_ROUTE, NL_NONROOT_RECV); 983 register_netdevice_notifier(&rtnetlink_dev_notifier); 984 985 rtnl_register(PF_UNSPEC, RTM_GETLINK, rtnl_getlink, rtnl_dump_ifinfo); 986 rtnl_register(PF_UNSPEC, RTM_SETLINK, rtnl_setlink, NULL); 987 988 rtnl_register(PF_UNSPEC, RTM_GETADDR, NULL, rtnl_dump_all); 989 rtnl_register(PF_UNSPEC, RTM_GETROUTE, NULL, rtnl_dump_all); 990} 991 992EXPORT_SYMBOL(__rta_fill); 993EXPORT_SYMBOL(rtattr_strlcpy); 994EXPORT_SYMBOL(rtattr_parse); 995EXPORT_SYMBOL(rtnetlink_put_metrics); 996EXPORT_SYMBOL(rtnl_lock); 997EXPORT_SYMBOL(rtnl_trylock); 998EXPORT_SYMBOL(rtnl_unlock); 999EXPORT_SYMBOL(rtnl_unicast); 1000EXPORT_SYMBOL(rtnl_notify); 1001EXPORT_SYMBOL(rtnl_set_sk_err); 1002