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