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/netlink.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 59 static DEFINE_MUTEX(rtnl_mutex); 60 static struct sock *rtnl; 61 62 void rtnl_lock(void) 63 { 64 mutex_lock(&rtnl_mutex); 65 } 66 67 void __rtnl_unlock(void) 68 { 69 mutex_unlock(&rtnl_mutex); 70 } 71 72 void rtnl_unlock(void) 73 { 74 mutex_unlock(&rtnl_mutex); 75 if (rtnl && rtnl->sk_receive_queue.qlen) 76 rtnl->sk_data_ready(rtnl, 0); 77 netdev_run_todo(); 78 } 79 80 int rtnl_trylock(void) 81 { 82 return mutex_trylock(&rtnl_mutex); 83 } 84 85 int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len) 86 { 87 memset(tb, 0, sizeof(struct rtattr*)*maxattr); 88 89 while (RTA_OK(rta, len)) { 90 unsigned flavor = rta->rta_type; 91 if (flavor && flavor <= maxattr) 92 tb[flavor-1] = rta; 93 rta = RTA_NEXT(rta, len); 94 } 95 return 0; 96 } 97 98 struct rtnetlink_link * rtnetlink_links[NPROTO]; 99 100 static const int rtm_min[RTM_NR_FAMILIES] = 101 { 102 [RTM_FAM(RTM_NEWLINK)] = NLMSG_LENGTH(sizeof(struct ifinfomsg)), 103 [RTM_FAM(RTM_NEWADDR)] = NLMSG_LENGTH(sizeof(struct ifaddrmsg)), 104 [RTM_FAM(RTM_NEWROUTE)] = NLMSG_LENGTH(sizeof(struct rtmsg)), 105 [RTM_FAM(RTM_NEWRULE)] = NLMSG_LENGTH(sizeof(struct fib_rule_hdr)), 106 [RTM_FAM(RTM_NEWQDISC)] = NLMSG_LENGTH(sizeof(struct tcmsg)), 107 [RTM_FAM(RTM_NEWTCLASS)] = NLMSG_LENGTH(sizeof(struct tcmsg)), 108 [RTM_FAM(RTM_NEWTFILTER)] = NLMSG_LENGTH(sizeof(struct tcmsg)), 109 [RTM_FAM(RTM_NEWACTION)] = NLMSG_LENGTH(sizeof(struct tcamsg)), 110 [RTM_FAM(RTM_GETMULTICAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)), 111 [RTM_FAM(RTM_GETANYCAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)), 112 }; 113 114 static const int rta_max[RTM_NR_FAMILIES] = 115 { 116 [RTM_FAM(RTM_NEWLINK)] = IFLA_MAX, 117 [RTM_FAM(RTM_NEWADDR)] = IFA_MAX, 118 [RTM_FAM(RTM_NEWROUTE)] = RTA_MAX, 119 [RTM_FAM(RTM_NEWRULE)] = FRA_MAX, 120 [RTM_FAM(RTM_NEWQDISC)] = TCA_MAX, 121 [RTM_FAM(RTM_NEWTCLASS)] = TCA_MAX, 122 [RTM_FAM(RTM_NEWTFILTER)] = TCA_MAX, 123 [RTM_FAM(RTM_NEWACTION)] = TCAA_MAX, 124 }; 125 126 void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data) 127 { 128 struct rtattr *rta; 129 int size = RTA_LENGTH(attrlen); 130 131 rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size)); 132 rta->rta_type = attrtype; 133 rta->rta_len = size; 134 memcpy(RTA_DATA(rta), data, attrlen); 135 memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size); 136 } 137 138 size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size) 139 { 140 size_t ret = RTA_PAYLOAD(rta); 141 char *src = RTA_DATA(rta); 142 143 if (ret > 0 && src[ret - 1] == '\0') 144 ret--; 145 if (size > 0) { 146 size_t len = (ret >= size) ? size - 1 : ret; 147 memset(dest, 0, size); 148 memcpy(dest, src, len); 149 } 150 return ret; 151 } 152 153 int rtnetlink_send(struct sk_buff *skb, u32 pid, unsigned group, int echo) 154 { 155 int err = 0; 156 157 NETLINK_CB(skb).dst_group = group; 158 if (echo) 159 atomic_inc(&skb->users); 160 netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL); 161 if (echo) 162 err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT); 163 return err; 164 } 165 166 int rtnl_unicast(struct sk_buff *skb, u32 pid) 167 { 168 return nlmsg_unicast(rtnl, skb, pid); 169 } 170 171 int rtnl_notify(struct sk_buff *skb, u32 pid, u32 group, 172 struct nlmsghdr *nlh, gfp_t flags) 173 { 174 int report = 0; 175 176 if (nlh) 177 report = nlmsg_report(nlh); 178 179 return nlmsg_notify(rtnl, skb, pid, group, report, flags); 180 } 181 182 void rtnl_set_sk_err(u32 group, int error) 183 { 184 netlink_set_err(rtnl, 0, group, error); 185 } 186 187 int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics) 188 { 189 struct nlattr *mx; 190 int i, valid = 0; 191 192 mx = nla_nest_start(skb, RTA_METRICS); 193 if (mx == NULL) 194 return -ENOBUFS; 195 196 for (i = 0; i < RTAX_MAX; i++) { 197 if (metrics[i]) { 198 valid++; 199 NLA_PUT_U32(skb, i+1, metrics[i]); 200 } 201 } 202 203 if (!valid) { 204 nla_nest_cancel(skb, mx); 205 return 0; 206 } 207 208 return nla_nest_end(skb, mx); 209 210 nla_put_failure: 211 return nla_nest_cancel(skb, mx); 212 } 213 214 int rtnl_put_cacheinfo(struct sk_buff *skb, struct dst_entry *dst, u32 id, 215 u32 ts, u32 tsage, long expires, u32 error) 216 { 217 struct rta_cacheinfo ci = { 218 .rta_lastuse = jiffies_to_clock_t(jiffies - dst->lastuse), 219 .rta_used = dst->__use, 220 .rta_clntref = atomic_read(&(dst->__refcnt)), 221 .rta_error = error, 222 .rta_id = id, 223 .rta_ts = ts, 224 .rta_tsage = tsage, 225 }; 226 227 if (expires) 228 ci.rta_expires = jiffies_to_clock_t(expires); 229 230 return nla_put(skb, RTA_CACHEINFO, sizeof(ci), &ci); 231 } 232 233 EXPORT_SYMBOL_GPL(rtnl_put_cacheinfo); 234 235 static void set_operstate(struct net_device *dev, unsigned char transition) 236 { 237 unsigned char operstate = dev->operstate; 238 239 switch(transition) { 240 case IF_OPER_UP: 241 if ((operstate == IF_OPER_DORMANT || 242 operstate == IF_OPER_UNKNOWN) && 243 !netif_dormant(dev)) 244 operstate = IF_OPER_UP; 245 break; 246 247 case IF_OPER_DORMANT: 248 if (operstate == IF_OPER_UP || 249 operstate == IF_OPER_UNKNOWN) 250 operstate = IF_OPER_DORMANT; 251 break; 252 }; 253 254 if (dev->operstate != operstate) { 255 write_lock_bh(&dev_base_lock); 256 dev->operstate = operstate; 257 write_unlock_bh(&dev_base_lock); 258 netdev_state_change(dev); 259 } 260 } 261 262 static void copy_rtnl_link_stats(struct rtnl_link_stats *a, 263 struct net_device_stats *b) 264 { 265 a->rx_packets = b->rx_packets; 266 a->tx_packets = b->tx_packets; 267 a->rx_bytes = b->rx_bytes; 268 a->tx_bytes = b->tx_bytes; 269 a->rx_errors = b->rx_errors; 270 a->tx_errors = b->tx_errors; 271 a->rx_dropped = b->rx_dropped; 272 a->tx_dropped = b->tx_dropped; 273 274 a->multicast = b->multicast; 275 a->collisions = b->collisions; 276 277 a->rx_length_errors = b->rx_length_errors; 278 a->rx_over_errors = b->rx_over_errors; 279 a->rx_crc_errors = b->rx_crc_errors; 280 a->rx_frame_errors = b->rx_frame_errors; 281 a->rx_fifo_errors = b->rx_fifo_errors; 282 a->rx_missed_errors = b->rx_missed_errors; 283 284 a->tx_aborted_errors = b->tx_aborted_errors; 285 a->tx_carrier_errors = b->tx_carrier_errors; 286 a->tx_fifo_errors = b->tx_fifo_errors; 287 a->tx_heartbeat_errors = b->tx_heartbeat_errors; 288 a->tx_window_errors = b->tx_window_errors; 289 290 a->rx_compressed = b->rx_compressed; 291 a->tx_compressed = b->tx_compressed; 292 }; 293 294 static inline size_t if_nlmsg_size(int iwbuflen) 295 { 296 return NLMSG_ALIGN(sizeof(struct ifinfomsg)) 297 + nla_total_size(IFNAMSIZ) /* IFLA_IFNAME */ 298 + nla_total_size(IFNAMSIZ) /* IFLA_QDISC */ 299 + nla_total_size(sizeof(struct rtnl_link_ifmap)) 300 + nla_total_size(sizeof(struct rtnl_link_stats)) 301 + nla_total_size(MAX_ADDR_LEN) /* IFLA_ADDRESS */ 302 + nla_total_size(MAX_ADDR_LEN) /* IFLA_BROADCAST */ 303 + nla_total_size(4) /* IFLA_TXQLEN */ 304 + nla_total_size(4) /* IFLA_WEIGHT */ 305 + nla_total_size(4) /* IFLA_MTU */ 306 + nla_total_size(4) /* IFLA_LINK */ 307 + nla_total_size(4) /* IFLA_MASTER */ 308 + nla_total_size(1) /* IFLA_OPERSTATE */ 309 + nla_total_size(1) /* IFLA_LINKMODE */ 310 + nla_total_size(iwbuflen); 311 } 312 313 static int rtnl_fill_ifinfo(struct sk_buff *skb, struct net_device *dev, 314 void *iwbuf, int iwbuflen, int type, u32 pid, 315 u32 seq, u32 change, unsigned int flags) 316 { 317 struct ifinfomsg *ifm; 318 struct nlmsghdr *nlh; 319 320 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*ifm), flags); 321 if (nlh == NULL) 322 return -EMSGSIZE; 323 324 ifm = nlmsg_data(nlh); 325 ifm->ifi_family = AF_UNSPEC; 326 ifm->__ifi_pad = 0; 327 ifm->ifi_type = dev->type; 328 ifm->ifi_index = dev->ifindex; 329 ifm->ifi_flags = dev_get_flags(dev); 330 ifm->ifi_change = change; 331 332 NLA_PUT_STRING(skb, IFLA_IFNAME, dev->name); 333 NLA_PUT_U32(skb, IFLA_TXQLEN, dev->tx_queue_len); 334 NLA_PUT_U32(skb, IFLA_WEIGHT, dev->weight); 335 NLA_PUT_U8(skb, IFLA_OPERSTATE, 336 netif_running(dev) ? dev->operstate : IF_OPER_DOWN); 337 NLA_PUT_U8(skb, IFLA_LINKMODE, dev->link_mode); 338 NLA_PUT_U32(skb, IFLA_MTU, dev->mtu); 339 340 if (dev->ifindex != dev->iflink) 341 NLA_PUT_U32(skb, IFLA_LINK, dev->iflink); 342 343 if (dev->master) 344 NLA_PUT_U32(skb, IFLA_MASTER, dev->master->ifindex); 345 346 if (dev->qdisc_sleeping) 347 NLA_PUT_STRING(skb, IFLA_QDISC, dev->qdisc_sleeping->ops->id); 348 349 if (1) { 350 struct rtnl_link_ifmap map = { 351 .mem_start = dev->mem_start, 352 .mem_end = dev->mem_end, 353 .base_addr = dev->base_addr, 354 .irq = dev->irq, 355 .dma = dev->dma, 356 .port = dev->if_port, 357 }; 358 NLA_PUT(skb, IFLA_MAP, sizeof(map), &map); 359 } 360 361 if (dev->addr_len) { 362 NLA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr); 363 NLA_PUT(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast); 364 } 365 366 if (dev->get_stats) { 367 struct net_device_stats *stats = dev->get_stats(dev); 368 if (stats) { 369 struct nlattr *attr; 370 371 attr = nla_reserve(skb, IFLA_STATS, 372 sizeof(struct rtnl_link_stats)); 373 if (attr == NULL) 374 goto nla_put_failure; 375 376 copy_rtnl_link_stats(nla_data(attr), stats); 377 } 378 } 379 380 if (iwbuf) 381 NLA_PUT(skb, IFLA_WIRELESS, iwbuflen, iwbuf); 382 383 return nlmsg_end(skb, nlh); 384 385 nla_put_failure: 386 nlmsg_cancel(skb, nlh); 387 return -EMSGSIZE; 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 if (err < 0) { 637 /* -EMSGSIZE implies BUG in if_nlmsg_size */ 638 WARN_ON(err == -EMSGSIZE); 639 kfree_skb(nskb); 640 goto errout; 641 } 642 err = rtnl_unicast(nskb, NETLINK_CB(skb).pid); 643 errout: 644 kfree(iw_buf); 645 dev_put(dev); 646 647 return err; 648 } 649 650 static int rtnl_dump_all(struct sk_buff *skb, struct netlink_callback *cb) 651 { 652 int idx; 653 int s_idx = cb->family; 654 655 if (s_idx == 0) 656 s_idx = 1; 657 for (idx=1; idx<NPROTO; idx++) { 658 int type = cb->nlh->nlmsg_type-RTM_BASE; 659 if (idx < s_idx || idx == PF_PACKET) 660 continue; 661 if (rtnetlink_links[idx] == NULL || 662 rtnetlink_links[idx][type].dumpit == NULL) 663 continue; 664 if (idx > s_idx) 665 memset(&cb->args[0], 0, sizeof(cb->args)); 666 if (rtnetlink_links[idx][type].dumpit(skb, cb)) 667 break; 668 } 669 cb->family = idx; 670 671 return skb->len; 672 } 673 674 void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change) 675 { 676 struct sk_buff *skb; 677 int err = -ENOBUFS; 678 679 skb = nlmsg_new(if_nlmsg_size(0), GFP_KERNEL); 680 if (skb == NULL) 681 goto errout; 682 683 err = rtnl_fill_ifinfo(skb, dev, NULL, 0, type, 0, 0, change, 0); 684 if (err < 0) { 685 /* -EMSGSIZE implies BUG in if_nlmsg_size() */ 686 WARN_ON(err == -EMSGSIZE); 687 kfree_skb(skb); 688 goto errout; 689 } 690 err = rtnl_notify(skb, 0, RTNLGRP_LINK, NULL, GFP_KERNEL); 691 errout: 692 if (err < 0) 693 rtnl_set_sk_err(RTNLGRP_LINK, err); 694 } 695 696 /* Protected by RTNL sempahore. */ 697 static struct rtattr **rta_buf; 698 static int rtattr_max; 699 700 /* Process one rtnetlink message. */ 701 702 static __inline__ int 703 rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, int *errp) 704 { 705 struct rtnetlink_link *link; 706 struct rtnetlink_link *link_tab; 707 int sz_idx, kind; 708 int min_len; 709 int family; 710 int type; 711 int err; 712 713 /* Only requests are handled by kernel now */ 714 if (!(nlh->nlmsg_flags&NLM_F_REQUEST)) 715 return 0; 716 717 type = nlh->nlmsg_type; 718 719 /* A control message: ignore them */ 720 if (type < RTM_BASE) 721 return 0; 722 723 /* Unknown message: reply with EINVAL */ 724 if (type > RTM_MAX) 725 goto err_inval; 726 727 type -= RTM_BASE; 728 729 /* All the messages must have at least 1 byte length */ 730 if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtgenmsg))) 731 return 0; 732 733 family = ((struct rtgenmsg*)NLMSG_DATA(nlh))->rtgen_family; 734 if (family >= NPROTO) { 735 *errp = -EAFNOSUPPORT; 736 return -1; 737 } 738 739 link_tab = rtnetlink_links[family]; 740 if (link_tab == NULL) 741 link_tab = rtnetlink_links[PF_UNSPEC]; 742 link = &link_tab[type]; 743 744 sz_idx = type>>2; 745 kind = type&3; 746 747 if (kind != 2 && security_netlink_recv(skb, CAP_NET_ADMIN)) { 748 *errp = -EPERM; 749 return -1; 750 } 751 752 if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) { 753 if (link->dumpit == NULL) 754 link = &(rtnetlink_links[PF_UNSPEC][type]); 755 756 if (link->dumpit == NULL) 757 goto err_inval; 758 759 if ((*errp = netlink_dump_start(rtnl, skb, nlh, 760 link->dumpit, NULL)) != 0) { 761 return -1; 762 } 763 764 netlink_queue_skip(nlh, skb); 765 return -1; 766 } 767 768 memset(rta_buf, 0, (rtattr_max * sizeof(struct rtattr *))); 769 770 min_len = rtm_min[sz_idx]; 771 if (nlh->nlmsg_len < min_len) 772 goto err_inval; 773 774 if (nlh->nlmsg_len > min_len) { 775 int attrlen = nlh->nlmsg_len - NLMSG_ALIGN(min_len); 776 struct rtattr *attr = (void*)nlh + NLMSG_ALIGN(min_len); 777 778 while (RTA_OK(attr, attrlen)) { 779 unsigned flavor = attr->rta_type; 780 if (flavor) { 781 if (flavor > rta_max[sz_idx]) 782 goto err_inval; 783 rta_buf[flavor-1] = attr; 784 } 785 attr = RTA_NEXT(attr, attrlen); 786 } 787 } 788 789 if (link->doit == NULL) 790 link = &(rtnetlink_links[PF_UNSPEC][type]); 791 if (link->doit == NULL) 792 goto err_inval; 793 err = link->doit(skb, nlh, (void *)&rta_buf[0]); 794 795 *errp = err; 796 return err; 797 798 err_inval: 799 *errp = -EINVAL; 800 return -1; 801 } 802 803 static void rtnetlink_rcv(struct sock *sk, int len) 804 { 805 unsigned int qlen = 0; 806 807 do { 808 mutex_lock(&rtnl_mutex); 809 netlink_run_queue(sk, &qlen, &rtnetlink_rcv_msg); 810 mutex_unlock(&rtnl_mutex); 811 812 netdev_run_todo(); 813 } while (qlen); 814 } 815 816 static struct rtnetlink_link link_rtnetlink_table[RTM_NR_MSGTYPES] = 817 { 818 [RTM_GETLINK - RTM_BASE] = { .doit = rtnl_getlink, 819 .dumpit = rtnl_dump_ifinfo }, 820 [RTM_SETLINK - RTM_BASE] = { .doit = rtnl_setlink }, 821 [RTM_GETADDR - RTM_BASE] = { .dumpit = rtnl_dump_all }, 822 [RTM_GETROUTE - RTM_BASE] = { .dumpit = rtnl_dump_all }, 823 [RTM_NEWNEIGH - RTM_BASE] = { .doit = neigh_add }, 824 [RTM_DELNEIGH - RTM_BASE] = { .doit = neigh_delete }, 825 [RTM_GETNEIGH - RTM_BASE] = { .dumpit = neigh_dump_info }, 826 #ifdef CONFIG_FIB_RULES 827 [RTM_NEWRULE - RTM_BASE] = { .doit = fib_nl_newrule }, 828 [RTM_DELRULE - RTM_BASE] = { .doit = fib_nl_delrule }, 829 #endif 830 [RTM_GETRULE - RTM_BASE] = { .dumpit = rtnl_dump_all }, 831 [RTM_GETNEIGHTBL - RTM_BASE] = { .dumpit = neightbl_dump_info }, 832 [RTM_SETNEIGHTBL - RTM_BASE] = { .doit = neightbl_set }, 833 }; 834 835 static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr) 836 { 837 struct net_device *dev = ptr; 838 switch (event) { 839 case NETDEV_UNREGISTER: 840 rtmsg_ifinfo(RTM_DELLINK, dev, ~0U); 841 break; 842 case NETDEV_REGISTER: 843 rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U); 844 break; 845 case NETDEV_UP: 846 case NETDEV_DOWN: 847 rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING); 848 break; 849 case NETDEV_CHANGE: 850 case NETDEV_GOING_DOWN: 851 break; 852 default: 853 rtmsg_ifinfo(RTM_NEWLINK, dev, 0); 854 break; 855 } 856 return NOTIFY_DONE; 857 } 858 859 static struct notifier_block rtnetlink_dev_notifier = { 860 .notifier_call = rtnetlink_event, 861 }; 862 863 void __init rtnetlink_init(void) 864 { 865 int i; 866 867 rtattr_max = 0; 868 for (i = 0; i < ARRAY_SIZE(rta_max); i++) 869 if (rta_max[i] > rtattr_max) 870 rtattr_max = rta_max[i]; 871 rta_buf = kmalloc(rtattr_max * sizeof(struct rtattr *), GFP_KERNEL); 872 if (!rta_buf) 873 panic("rtnetlink_init: cannot allocate rta_buf\n"); 874 875 rtnl = netlink_kernel_create(NETLINK_ROUTE, RTNLGRP_MAX, rtnetlink_rcv, 876 THIS_MODULE); 877 if (rtnl == NULL) 878 panic("rtnetlink_init: cannot initialize rtnetlink\n"); 879 netlink_set_nonroot(NETLINK_ROUTE, NL_NONROOT_RECV); 880 register_netdevice_notifier(&rtnetlink_dev_notifier); 881 rtnetlink_links[PF_UNSPEC] = link_rtnetlink_table; 882 rtnetlink_links[PF_PACKET] = link_rtnetlink_table; 883 } 884 885 EXPORT_SYMBOL(__rta_fill); 886 EXPORT_SYMBOL(rtattr_strlcpy); 887 EXPORT_SYMBOL(rtattr_parse); 888 EXPORT_SYMBOL(rtnetlink_links); 889 EXPORT_SYMBOL(rtnetlink_put_metrics); 890 EXPORT_SYMBOL(rtnl_lock); 891 EXPORT_SYMBOL(rtnl_trylock); 892 EXPORT_SYMBOL(rtnl_unlock); 893 EXPORT_SYMBOL(rtnl_unicast); 894 EXPORT_SYMBOL(rtnl_notify); 895 EXPORT_SYMBOL(rtnl_set_sk_err); 896