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