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 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/netlink.h> 53 #ifdef CONFIG_NET_WIRELESS_RTNETLINK 54 #include <linux/wireless.h> 55 #include <net/iw_handler.h> 56 #endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 57 58 static DEFINE_MUTEX(rtnl_mutex); 59 60 void rtnl_lock(void) 61 { 62 mutex_lock(&rtnl_mutex); 63 } 64 65 void __rtnl_unlock(void) 66 { 67 mutex_unlock(&rtnl_mutex); 68 } 69 70 void rtnl_unlock(void) 71 { 72 mutex_unlock(&rtnl_mutex); 73 if (rtnl && rtnl->sk_receive_queue.qlen) 74 rtnl->sk_data_ready(rtnl, 0); 75 netdev_run_todo(); 76 } 77 78 int rtnl_trylock(void) 79 { 80 return mutex_trylock(&rtnl_mutex); 81 } 82 83 int rtattr_parse(struct rtattr *tb[], int maxattr, struct rtattr *rta, int len) 84 { 85 memset(tb, 0, sizeof(struct rtattr*)*maxattr); 86 87 while (RTA_OK(rta, len)) { 88 unsigned flavor = rta->rta_type; 89 if (flavor && flavor <= maxattr) 90 tb[flavor-1] = rta; 91 rta = RTA_NEXT(rta, len); 92 } 93 return 0; 94 } 95 96 struct sock *rtnl; 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_NEWNEIGH)] = NLMSG_LENGTH(sizeof(struct ndmsg)), 106 [RTM_FAM(RTM_NEWRULE)] = NLMSG_LENGTH(sizeof(struct rtmsg)), 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_NEWPREFIX)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)), 112 [RTM_FAM(RTM_GETMULTICAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)), 113 [RTM_FAM(RTM_GETANYCAST)] = NLMSG_LENGTH(sizeof(struct rtgenmsg)), 114 [RTM_FAM(RTM_NEWNEIGHTBL)] = NLMSG_LENGTH(sizeof(struct ndtmsg)), 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_NEWNEIGH)] = NDA_MAX, 123 [RTM_FAM(RTM_NEWRULE)] = RTA_MAX, 124 [RTM_FAM(RTM_NEWQDISC)] = TCA_MAX, 125 [RTM_FAM(RTM_NEWTCLASS)] = TCA_MAX, 126 [RTM_FAM(RTM_NEWTFILTER)] = TCA_MAX, 127 [RTM_FAM(RTM_NEWACTION)] = TCAA_MAX, 128 [RTM_FAM(RTM_NEWNEIGHTBL)] = NDTA_MAX, 129 }; 130 131 void __rta_fill(struct sk_buff *skb, int attrtype, int attrlen, const void *data) 132 { 133 struct rtattr *rta; 134 int size = RTA_LENGTH(attrlen); 135 136 rta = (struct rtattr*)skb_put(skb, RTA_ALIGN(size)); 137 rta->rta_type = attrtype; 138 rta->rta_len = size; 139 memcpy(RTA_DATA(rta), data, attrlen); 140 memset(RTA_DATA(rta) + attrlen, 0, RTA_ALIGN(size) - size); 141 } 142 143 size_t rtattr_strlcpy(char *dest, const struct rtattr *rta, size_t size) 144 { 145 size_t ret = RTA_PAYLOAD(rta); 146 char *src = RTA_DATA(rta); 147 148 if (ret > 0 && src[ret - 1] == '\0') 149 ret--; 150 if (size > 0) { 151 size_t len = (ret >= size) ? size - 1 : ret; 152 memset(dest, 0, size); 153 memcpy(dest, src, len); 154 } 155 return ret; 156 } 157 158 int rtnetlink_send(struct sk_buff *skb, u32 pid, unsigned group, int echo) 159 { 160 int err = 0; 161 162 NETLINK_CB(skb).dst_group = group; 163 if (echo) 164 atomic_inc(&skb->users); 165 netlink_broadcast(rtnl, skb, pid, group, GFP_KERNEL); 166 if (echo) 167 err = netlink_unicast(rtnl, skb, pid, MSG_DONTWAIT); 168 return err; 169 } 170 171 int rtnetlink_put_metrics(struct sk_buff *skb, u32 *metrics) 172 { 173 struct rtattr *mx = (struct rtattr*)skb->tail; 174 int i; 175 176 RTA_PUT(skb, RTA_METRICS, 0, NULL); 177 for (i=0; i<RTAX_MAX; i++) { 178 if (metrics[i]) 179 RTA_PUT(skb, i+1, sizeof(u32), metrics+i); 180 } 181 mx->rta_len = skb->tail - (u8*)mx; 182 if (mx->rta_len == RTA_LENGTH(0)) 183 skb_trim(skb, (u8*)mx - skb->data); 184 return 0; 185 186 rtattr_failure: 187 skb_trim(skb, (u8*)mx - skb->data); 188 return -1; 189 } 190 191 192 static void set_operstate(struct net_device *dev, unsigned char transition) 193 { 194 unsigned char operstate = dev->operstate; 195 196 switch(transition) { 197 case IF_OPER_UP: 198 if ((operstate == IF_OPER_DORMANT || 199 operstate == IF_OPER_UNKNOWN) && 200 !netif_dormant(dev)) 201 operstate = IF_OPER_UP; 202 break; 203 204 case IF_OPER_DORMANT: 205 if (operstate == IF_OPER_UP || 206 operstate == IF_OPER_UNKNOWN) 207 operstate = IF_OPER_DORMANT; 208 break; 209 }; 210 211 if (dev->operstate != operstate) { 212 write_lock_bh(&dev_base_lock); 213 dev->operstate = operstate; 214 write_unlock_bh(&dev_base_lock); 215 netdev_state_change(dev); 216 } 217 } 218 219 static int rtnetlink_fill_ifinfo(struct sk_buff *skb, struct net_device *dev, 220 int type, u32 pid, u32 seq, u32 change, 221 unsigned int flags) 222 { 223 struct ifinfomsg *r; 224 struct nlmsghdr *nlh; 225 unsigned char *b = skb->tail; 226 227 nlh = NLMSG_NEW(skb, pid, seq, type, sizeof(*r), flags); 228 r = NLMSG_DATA(nlh); 229 r->ifi_family = AF_UNSPEC; 230 r->__ifi_pad = 0; 231 r->ifi_type = dev->type; 232 r->ifi_index = dev->ifindex; 233 r->ifi_flags = dev_get_flags(dev); 234 r->ifi_change = change; 235 236 RTA_PUT(skb, IFLA_IFNAME, strlen(dev->name)+1, dev->name); 237 238 if (1) { 239 u32 txqlen = dev->tx_queue_len; 240 RTA_PUT(skb, IFLA_TXQLEN, sizeof(txqlen), &txqlen); 241 } 242 243 if (1) { 244 u32 weight = dev->weight; 245 RTA_PUT(skb, IFLA_WEIGHT, sizeof(weight), &weight); 246 } 247 248 if (1) { 249 u8 operstate = netif_running(dev)?dev->operstate:IF_OPER_DOWN; 250 u8 link_mode = dev->link_mode; 251 RTA_PUT(skb, IFLA_OPERSTATE, sizeof(operstate), &operstate); 252 RTA_PUT(skb, IFLA_LINKMODE, sizeof(link_mode), &link_mode); 253 } 254 255 if (1) { 256 struct rtnl_link_ifmap map = { 257 .mem_start = dev->mem_start, 258 .mem_end = dev->mem_end, 259 .base_addr = dev->base_addr, 260 .irq = dev->irq, 261 .dma = dev->dma, 262 .port = dev->if_port, 263 }; 264 RTA_PUT(skb, IFLA_MAP, sizeof(map), &map); 265 } 266 267 if (dev->addr_len) { 268 RTA_PUT(skb, IFLA_ADDRESS, dev->addr_len, dev->dev_addr); 269 RTA_PUT(skb, IFLA_BROADCAST, dev->addr_len, dev->broadcast); 270 } 271 272 if (1) { 273 u32 mtu = dev->mtu; 274 RTA_PUT(skb, IFLA_MTU, sizeof(mtu), &mtu); 275 } 276 277 if (dev->ifindex != dev->iflink) { 278 u32 iflink = dev->iflink; 279 RTA_PUT(skb, IFLA_LINK, sizeof(iflink), &iflink); 280 } 281 282 if (dev->qdisc_sleeping) 283 RTA_PUT(skb, IFLA_QDISC, 284 strlen(dev->qdisc_sleeping->ops->id) + 1, 285 dev->qdisc_sleeping->ops->id); 286 287 if (dev->master) { 288 u32 master = dev->master->ifindex; 289 RTA_PUT(skb, IFLA_MASTER, sizeof(master), &master); 290 } 291 292 if (dev->get_stats) { 293 unsigned long *stats = (unsigned long*)dev->get_stats(dev); 294 if (stats) { 295 struct rtattr *a; 296 __u32 *s; 297 int i; 298 int n = sizeof(struct rtnl_link_stats)/4; 299 300 a = __RTA_PUT(skb, IFLA_STATS, n*4); 301 s = RTA_DATA(a); 302 for (i=0; i<n; i++) 303 s[i] = stats[i]; 304 } 305 } 306 nlh->nlmsg_len = skb->tail - b; 307 return skb->len; 308 309 nlmsg_failure: 310 rtattr_failure: 311 skb_trim(skb, b - skb->data); 312 return -1; 313 } 314 315 static int rtnetlink_dump_ifinfo(struct sk_buff *skb, struct netlink_callback *cb) 316 { 317 int idx; 318 int s_idx = cb->args[0]; 319 struct net_device *dev; 320 321 read_lock(&dev_base_lock); 322 for (dev=dev_base, idx=0; dev; dev = dev->next, idx++) { 323 if (idx < s_idx) 324 continue; 325 if (rtnetlink_fill_ifinfo(skb, dev, RTM_NEWLINK, 326 NETLINK_CB(cb->skb).pid, 327 cb->nlh->nlmsg_seq, 0, 328 NLM_F_MULTI) <= 0) 329 break; 330 } 331 read_unlock(&dev_base_lock); 332 cb->args[0] = idx; 333 334 return skb->len; 335 } 336 337 static int do_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg) 338 { 339 struct ifinfomsg *ifm = NLMSG_DATA(nlh); 340 struct rtattr **ida = arg; 341 struct net_device *dev; 342 int err, send_addr_notify = 0; 343 344 if (ifm->ifi_index >= 0) 345 dev = dev_get_by_index(ifm->ifi_index); 346 else if (ida[IFLA_IFNAME - 1]) { 347 char ifname[IFNAMSIZ]; 348 349 if (rtattr_strlcpy(ifname, ida[IFLA_IFNAME - 1], 350 IFNAMSIZ) >= IFNAMSIZ) 351 return -EINVAL; 352 dev = dev_get_by_name(ifname); 353 } else 354 return -EINVAL; 355 356 if (!dev) 357 return -ENODEV; 358 359 err = -EINVAL; 360 361 if (ifm->ifi_flags) 362 dev_change_flags(dev, ifm->ifi_flags); 363 364 if (ida[IFLA_MAP - 1]) { 365 struct rtnl_link_ifmap *u_map; 366 struct ifmap k_map; 367 368 if (!dev->set_config) { 369 err = -EOPNOTSUPP; 370 goto out; 371 } 372 373 if (!netif_device_present(dev)) { 374 err = -ENODEV; 375 goto out; 376 } 377 378 if (ida[IFLA_MAP - 1]->rta_len != RTA_LENGTH(sizeof(*u_map))) 379 goto out; 380 381 u_map = RTA_DATA(ida[IFLA_MAP - 1]); 382 383 k_map.mem_start = (unsigned long) u_map->mem_start; 384 k_map.mem_end = (unsigned long) u_map->mem_end; 385 k_map.base_addr = (unsigned short) u_map->base_addr; 386 k_map.irq = (unsigned char) u_map->irq; 387 k_map.dma = (unsigned char) u_map->dma; 388 k_map.port = (unsigned char) u_map->port; 389 390 err = dev->set_config(dev, &k_map); 391 392 if (err) 393 goto out; 394 } 395 396 if (ida[IFLA_ADDRESS - 1]) { 397 if (!dev->set_mac_address) { 398 err = -EOPNOTSUPP; 399 goto out; 400 } 401 if (!netif_device_present(dev)) { 402 err = -ENODEV; 403 goto out; 404 } 405 if (ida[IFLA_ADDRESS - 1]->rta_len != RTA_LENGTH(dev->addr_len)) 406 goto out; 407 408 err = dev->set_mac_address(dev, RTA_DATA(ida[IFLA_ADDRESS - 1])); 409 if (err) 410 goto out; 411 send_addr_notify = 1; 412 } 413 414 if (ida[IFLA_BROADCAST - 1]) { 415 if (ida[IFLA_BROADCAST - 1]->rta_len != RTA_LENGTH(dev->addr_len)) 416 goto out; 417 memcpy(dev->broadcast, RTA_DATA(ida[IFLA_BROADCAST - 1]), 418 dev->addr_len); 419 send_addr_notify = 1; 420 } 421 422 if (ida[IFLA_MTU - 1]) { 423 if (ida[IFLA_MTU - 1]->rta_len != RTA_LENGTH(sizeof(u32))) 424 goto out; 425 err = dev_set_mtu(dev, *((u32 *) RTA_DATA(ida[IFLA_MTU - 1]))); 426 427 if (err) 428 goto out; 429 430 } 431 432 if (ida[IFLA_TXQLEN - 1]) { 433 if (ida[IFLA_TXQLEN - 1]->rta_len != RTA_LENGTH(sizeof(u32))) 434 goto out; 435 436 dev->tx_queue_len = *((u32 *) RTA_DATA(ida[IFLA_TXQLEN - 1])); 437 } 438 439 if (ida[IFLA_WEIGHT - 1]) { 440 if (ida[IFLA_WEIGHT - 1]->rta_len != RTA_LENGTH(sizeof(u32))) 441 goto out; 442 443 dev->weight = *((u32 *) RTA_DATA(ida[IFLA_WEIGHT - 1])); 444 } 445 446 if (ida[IFLA_OPERSTATE - 1]) { 447 if (ida[IFLA_OPERSTATE - 1]->rta_len != RTA_LENGTH(sizeof(u8))) 448 goto out; 449 450 set_operstate(dev, *((u8 *) RTA_DATA(ida[IFLA_OPERSTATE - 1]))); 451 } 452 453 if (ida[IFLA_LINKMODE - 1]) { 454 if (ida[IFLA_LINKMODE - 1]->rta_len != RTA_LENGTH(sizeof(u8))) 455 goto out; 456 457 write_lock_bh(&dev_base_lock); 458 dev->link_mode = *((u8 *) RTA_DATA(ida[IFLA_LINKMODE - 1])); 459 write_unlock_bh(&dev_base_lock); 460 } 461 462 if (ifm->ifi_index >= 0 && ida[IFLA_IFNAME - 1]) { 463 char ifname[IFNAMSIZ]; 464 465 if (rtattr_strlcpy(ifname, ida[IFLA_IFNAME - 1], 466 IFNAMSIZ) >= IFNAMSIZ) 467 goto out; 468 err = dev_change_name(dev, ifname); 469 if (err) 470 goto out; 471 } 472 473 #ifdef CONFIG_NET_WIRELESS_RTNETLINK 474 if (ida[IFLA_WIRELESS - 1]) { 475 476 /* Call Wireless Extensions. 477 * Various stuff checked in there... */ 478 err = wireless_rtnetlink_set(dev, RTA_DATA(ida[IFLA_WIRELESS - 1]), ida[IFLA_WIRELESS - 1]->rta_len); 479 if (err) 480 goto out; 481 } 482 #endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 483 484 err = 0; 485 486 out: 487 if (send_addr_notify) 488 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); 489 490 dev_put(dev); 491 return err; 492 } 493 494 #ifdef CONFIG_NET_WIRELESS_RTNETLINK 495 static int do_getlink(struct sk_buff *in_skb, struct nlmsghdr* in_nlh, void *arg) 496 { 497 struct ifinfomsg *ifm = NLMSG_DATA(in_nlh); 498 struct rtattr **ida = arg; 499 struct net_device *dev; 500 struct ifinfomsg *r; 501 struct nlmsghdr *nlh; 502 int err = -ENOBUFS; 503 struct sk_buff *skb; 504 unsigned char *b; 505 char *iw_buf = NULL; 506 int iw_buf_len = 0; 507 508 if (ifm->ifi_index >= 0) 509 dev = dev_get_by_index(ifm->ifi_index); 510 else 511 return -EINVAL; 512 if (!dev) 513 return -ENODEV; 514 515 #ifdef CONFIG_NET_WIRELESS_RTNETLINK 516 if (ida[IFLA_WIRELESS - 1]) { 517 518 /* Call Wireless Extensions. We need to know the size before 519 * we can alloc. Various stuff checked in there... */ 520 err = wireless_rtnetlink_get(dev, RTA_DATA(ida[IFLA_WIRELESS - 1]), ida[IFLA_WIRELESS - 1]->rta_len, &iw_buf, &iw_buf_len); 521 if (err) 522 goto out; 523 } 524 #endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 525 526 /* Create a skb big enough to include all the data. 527 * Some requests are way bigger than 4k... Jean II */ 528 skb = alloc_skb((NLMSG_LENGTH(sizeof(*r))) + (RTA_SPACE(iw_buf_len)), 529 GFP_KERNEL); 530 if (!skb) 531 goto out; 532 b = skb->tail; 533 534 /* Put in the message the usual good stuff */ 535 nlh = NLMSG_PUT(skb, NETLINK_CB(in_skb).pid, in_nlh->nlmsg_seq, 536 RTM_NEWLINK, sizeof(*r)); 537 r = NLMSG_DATA(nlh); 538 r->ifi_family = AF_UNSPEC; 539 r->__ifi_pad = 0; 540 r->ifi_type = dev->type; 541 r->ifi_index = dev->ifindex; 542 r->ifi_flags = dev->flags; 543 r->ifi_change = 0; 544 545 /* Put the wireless payload if it exist */ 546 if(iw_buf != NULL) 547 RTA_PUT(skb, IFLA_WIRELESS, iw_buf_len, 548 iw_buf + IW_EV_POINT_OFF); 549 550 nlh->nlmsg_len = skb->tail - b; 551 552 /* Needed ? */ 553 NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid; 554 555 err = netlink_unicast(rtnl, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT); 556 if (err > 0) 557 err = 0; 558 out: 559 if(iw_buf != NULL) 560 kfree(iw_buf); 561 dev_put(dev); 562 return err; 563 564 rtattr_failure: 565 nlmsg_failure: 566 kfree_skb(skb); 567 goto out; 568 } 569 #endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 570 571 static int rtnetlink_dump_all(struct sk_buff *skb, struct netlink_callback *cb) 572 { 573 int idx; 574 int s_idx = cb->family; 575 576 if (s_idx == 0) 577 s_idx = 1; 578 for (idx=1; idx<NPROTO; idx++) { 579 int type = cb->nlh->nlmsg_type-RTM_BASE; 580 if (idx < s_idx || idx == PF_PACKET) 581 continue; 582 if (rtnetlink_links[idx] == NULL || 583 rtnetlink_links[idx][type].dumpit == NULL) 584 continue; 585 if (idx > s_idx) 586 memset(&cb->args[0], 0, sizeof(cb->args)); 587 if (rtnetlink_links[idx][type].dumpit(skb, cb)) 588 break; 589 } 590 cb->family = idx; 591 592 return skb->len; 593 } 594 595 void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change) 596 { 597 struct sk_buff *skb; 598 int size = NLMSG_SPACE(sizeof(struct ifinfomsg) + 599 sizeof(struct rtnl_link_ifmap) + 600 sizeof(struct rtnl_link_stats) + 128); 601 602 skb = alloc_skb(size, GFP_KERNEL); 603 if (!skb) 604 return; 605 606 if (rtnetlink_fill_ifinfo(skb, dev, type, 0, 0, change, 0) < 0) { 607 kfree_skb(skb); 608 return; 609 } 610 NETLINK_CB(skb).dst_group = RTNLGRP_LINK; 611 netlink_broadcast(rtnl, skb, 0, RTNLGRP_LINK, GFP_KERNEL); 612 } 613 614 /* Protected by RTNL sempahore. */ 615 static struct rtattr **rta_buf; 616 static int rtattr_max; 617 618 /* Process one rtnetlink message. */ 619 620 static __inline__ int 621 rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, int *errp) 622 { 623 struct rtnetlink_link *link; 624 struct rtnetlink_link *link_tab; 625 int sz_idx, kind; 626 int min_len; 627 int family; 628 int type; 629 int err; 630 631 /* Only requests are handled by kernel now */ 632 if (!(nlh->nlmsg_flags&NLM_F_REQUEST)) 633 return 0; 634 635 type = nlh->nlmsg_type; 636 637 /* A control message: ignore them */ 638 if (type < RTM_BASE) 639 return 0; 640 641 /* Unknown message: reply with EINVAL */ 642 if (type > RTM_MAX) 643 goto err_inval; 644 645 type -= RTM_BASE; 646 647 /* All the messages must have at least 1 byte length */ 648 if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtgenmsg))) 649 return 0; 650 651 family = ((struct rtgenmsg*)NLMSG_DATA(nlh))->rtgen_family; 652 if (family >= NPROTO) { 653 *errp = -EAFNOSUPPORT; 654 return -1; 655 } 656 657 link_tab = rtnetlink_links[family]; 658 if (link_tab == NULL) 659 link_tab = rtnetlink_links[PF_UNSPEC]; 660 link = &link_tab[type]; 661 662 sz_idx = type>>2; 663 kind = type&3; 664 665 if (kind != 2 && security_netlink_recv(skb, CAP_NET_ADMIN)) { 666 *errp = -EPERM; 667 return -1; 668 } 669 670 if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) { 671 if (link->dumpit == NULL) 672 link = &(rtnetlink_links[PF_UNSPEC][type]); 673 674 if (link->dumpit == NULL) 675 goto err_inval; 676 677 if ((*errp = netlink_dump_start(rtnl, skb, nlh, 678 link->dumpit, NULL)) != 0) { 679 return -1; 680 } 681 682 netlink_queue_skip(nlh, skb); 683 return -1; 684 } 685 686 memset(rta_buf, 0, (rtattr_max * sizeof(struct rtattr *))); 687 688 min_len = rtm_min[sz_idx]; 689 if (nlh->nlmsg_len < min_len) 690 goto err_inval; 691 692 if (nlh->nlmsg_len > min_len) { 693 int attrlen = nlh->nlmsg_len - NLMSG_ALIGN(min_len); 694 struct rtattr *attr = (void*)nlh + NLMSG_ALIGN(min_len); 695 696 while (RTA_OK(attr, attrlen)) { 697 unsigned flavor = attr->rta_type; 698 if (flavor) { 699 if (flavor > rta_max[sz_idx]) 700 goto err_inval; 701 rta_buf[flavor-1] = attr; 702 } 703 attr = RTA_NEXT(attr, attrlen); 704 } 705 } 706 707 if (link->doit == NULL) 708 link = &(rtnetlink_links[PF_UNSPEC][type]); 709 if (link->doit == NULL) 710 goto err_inval; 711 err = link->doit(skb, nlh, (void *)&rta_buf[0]); 712 713 *errp = err; 714 return err; 715 716 err_inval: 717 *errp = -EINVAL; 718 return -1; 719 } 720 721 static void rtnetlink_rcv(struct sock *sk, int len) 722 { 723 unsigned int qlen = 0; 724 725 do { 726 mutex_lock(&rtnl_mutex); 727 netlink_run_queue(sk, &qlen, &rtnetlink_rcv_msg); 728 mutex_unlock(&rtnl_mutex); 729 730 netdev_run_todo(); 731 } while (qlen); 732 } 733 734 static struct rtnetlink_link link_rtnetlink_table[RTM_NR_MSGTYPES] = 735 { 736 [RTM_GETLINK - RTM_BASE] = { 737 #ifdef CONFIG_NET_WIRELESS_RTNETLINK 738 .doit = do_getlink, 739 #endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 740 .dumpit = rtnetlink_dump_ifinfo }, 741 [RTM_SETLINK - RTM_BASE] = { .doit = do_setlink }, 742 [RTM_GETADDR - RTM_BASE] = { .dumpit = rtnetlink_dump_all }, 743 [RTM_GETROUTE - RTM_BASE] = { .dumpit = rtnetlink_dump_all }, 744 [RTM_NEWNEIGH - RTM_BASE] = { .doit = neigh_add }, 745 [RTM_DELNEIGH - RTM_BASE] = { .doit = neigh_delete }, 746 [RTM_GETNEIGH - RTM_BASE] = { .dumpit = neigh_dump_info }, 747 [RTM_GETRULE - RTM_BASE] = { .dumpit = rtnetlink_dump_all }, 748 [RTM_GETNEIGHTBL - RTM_BASE] = { .dumpit = neightbl_dump_info }, 749 [RTM_SETNEIGHTBL - RTM_BASE] = { .doit = neightbl_set }, 750 }; 751 752 static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr) 753 { 754 struct net_device *dev = ptr; 755 switch (event) { 756 case NETDEV_UNREGISTER: 757 rtmsg_ifinfo(RTM_DELLINK, dev, ~0U); 758 break; 759 case NETDEV_REGISTER: 760 rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U); 761 break; 762 case NETDEV_UP: 763 case NETDEV_DOWN: 764 rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING); 765 break; 766 case NETDEV_CHANGE: 767 case NETDEV_GOING_DOWN: 768 break; 769 default: 770 rtmsg_ifinfo(RTM_NEWLINK, dev, 0); 771 break; 772 } 773 return NOTIFY_DONE; 774 } 775 776 static struct notifier_block rtnetlink_dev_notifier = { 777 .notifier_call = rtnetlink_event, 778 }; 779 780 void __init rtnetlink_init(void) 781 { 782 int i; 783 784 rtattr_max = 0; 785 for (i = 0; i < ARRAY_SIZE(rta_max); i++) 786 if (rta_max[i] > rtattr_max) 787 rtattr_max = rta_max[i]; 788 rta_buf = kmalloc(rtattr_max * sizeof(struct rtattr *), GFP_KERNEL); 789 if (!rta_buf) 790 panic("rtnetlink_init: cannot allocate rta_buf\n"); 791 792 rtnl = netlink_kernel_create(NETLINK_ROUTE, RTNLGRP_MAX, rtnetlink_rcv, 793 THIS_MODULE); 794 if (rtnl == NULL) 795 panic("rtnetlink_init: cannot initialize rtnetlink\n"); 796 netlink_set_nonroot(NETLINK_ROUTE, NL_NONROOT_RECV); 797 register_netdevice_notifier(&rtnetlink_dev_notifier); 798 rtnetlink_links[PF_UNSPEC] = link_rtnetlink_table; 799 rtnetlink_links[PF_PACKET] = link_rtnetlink_table; 800 } 801 802 EXPORT_SYMBOL(__rta_fill); 803 EXPORT_SYMBOL(rtattr_strlcpy); 804 EXPORT_SYMBOL(rtattr_parse); 805 EXPORT_SYMBOL(rtnetlink_links); 806 EXPORT_SYMBOL(rtnetlink_put_metrics); 807 EXPORT_SYMBOL(rtnl); 808 EXPORT_SYMBOL(rtnl_lock); 809 EXPORT_SYMBOL(rtnl_trylock); 810 EXPORT_SYMBOL(rtnl_unlock); 811