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 struct sockaddr *sa; 398 int len; 399 400 if (!dev->set_mac_address) { 401 err = -EOPNOTSUPP; 402 goto out; 403 } 404 if (!netif_device_present(dev)) { 405 err = -ENODEV; 406 goto out; 407 } 408 if (ida[IFLA_ADDRESS - 1]->rta_len != RTA_LENGTH(dev->addr_len)) 409 goto out; 410 411 len = sizeof(sa_family_t) + dev->addr_len; 412 sa = kmalloc(len, GFP_KERNEL); 413 if (!sa) { 414 err = -ENOMEM; 415 goto out; 416 } 417 sa->sa_family = dev->type; 418 memcpy(sa->sa_data, RTA_DATA(ida[IFLA_ADDRESS - 1]), 419 dev->addr_len); 420 err = dev->set_mac_address(dev, sa); 421 kfree(sa); 422 if (err) 423 goto out; 424 send_addr_notify = 1; 425 } 426 427 if (ida[IFLA_BROADCAST - 1]) { 428 if (ida[IFLA_BROADCAST - 1]->rta_len != RTA_LENGTH(dev->addr_len)) 429 goto out; 430 memcpy(dev->broadcast, RTA_DATA(ida[IFLA_BROADCAST - 1]), 431 dev->addr_len); 432 send_addr_notify = 1; 433 } 434 435 if (ida[IFLA_MTU - 1]) { 436 if (ida[IFLA_MTU - 1]->rta_len != RTA_LENGTH(sizeof(u32))) 437 goto out; 438 err = dev_set_mtu(dev, *((u32 *) RTA_DATA(ida[IFLA_MTU - 1]))); 439 440 if (err) 441 goto out; 442 443 } 444 445 if (ida[IFLA_TXQLEN - 1]) { 446 if (ida[IFLA_TXQLEN - 1]->rta_len != RTA_LENGTH(sizeof(u32))) 447 goto out; 448 449 dev->tx_queue_len = *((u32 *) RTA_DATA(ida[IFLA_TXQLEN - 1])); 450 } 451 452 if (ida[IFLA_WEIGHT - 1]) { 453 if (ida[IFLA_WEIGHT - 1]->rta_len != RTA_LENGTH(sizeof(u32))) 454 goto out; 455 456 dev->weight = *((u32 *) RTA_DATA(ida[IFLA_WEIGHT - 1])); 457 } 458 459 if (ida[IFLA_OPERSTATE - 1]) { 460 if (ida[IFLA_OPERSTATE - 1]->rta_len != RTA_LENGTH(sizeof(u8))) 461 goto out; 462 463 set_operstate(dev, *((u8 *) RTA_DATA(ida[IFLA_OPERSTATE - 1]))); 464 } 465 466 if (ida[IFLA_LINKMODE - 1]) { 467 if (ida[IFLA_LINKMODE - 1]->rta_len != RTA_LENGTH(sizeof(u8))) 468 goto out; 469 470 write_lock_bh(&dev_base_lock); 471 dev->link_mode = *((u8 *) RTA_DATA(ida[IFLA_LINKMODE - 1])); 472 write_unlock_bh(&dev_base_lock); 473 } 474 475 if (ifm->ifi_index >= 0 && ida[IFLA_IFNAME - 1]) { 476 char ifname[IFNAMSIZ]; 477 478 if (rtattr_strlcpy(ifname, ida[IFLA_IFNAME - 1], 479 IFNAMSIZ) >= IFNAMSIZ) 480 goto out; 481 err = dev_change_name(dev, ifname); 482 if (err) 483 goto out; 484 } 485 486 #ifdef CONFIG_NET_WIRELESS_RTNETLINK 487 if (ida[IFLA_WIRELESS - 1]) { 488 489 /* Call Wireless Extensions. 490 * Various stuff checked in there... */ 491 err = wireless_rtnetlink_set(dev, RTA_DATA(ida[IFLA_WIRELESS - 1]), ida[IFLA_WIRELESS - 1]->rta_len); 492 if (err) 493 goto out; 494 } 495 #endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 496 497 err = 0; 498 499 out: 500 if (send_addr_notify) 501 call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); 502 503 dev_put(dev); 504 return err; 505 } 506 507 #ifdef CONFIG_NET_WIRELESS_RTNETLINK 508 static int do_getlink(struct sk_buff *in_skb, struct nlmsghdr* in_nlh, void *arg) 509 { 510 struct ifinfomsg *ifm = NLMSG_DATA(in_nlh); 511 struct rtattr **ida = arg; 512 struct net_device *dev; 513 struct ifinfomsg *r; 514 struct nlmsghdr *nlh; 515 int err = -ENOBUFS; 516 struct sk_buff *skb; 517 unsigned char *b; 518 char *iw_buf = NULL; 519 int iw_buf_len = 0; 520 521 if (ifm->ifi_index >= 0) 522 dev = dev_get_by_index(ifm->ifi_index); 523 else 524 return -EINVAL; 525 if (!dev) 526 return -ENODEV; 527 528 #ifdef CONFIG_NET_WIRELESS_RTNETLINK 529 if (ida[IFLA_WIRELESS - 1]) { 530 531 /* Call Wireless Extensions. We need to know the size before 532 * we can alloc. Various stuff checked in there... */ 533 err = wireless_rtnetlink_get(dev, RTA_DATA(ida[IFLA_WIRELESS - 1]), ida[IFLA_WIRELESS - 1]->rta_len, &iw_buf, &iw_buf_len); 534 if (err) 535 goto out; 536 } 537 #endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 538 539 /* Create a skb big enough to include all the data. 540 * Some requests are way bigger than 4k... Jean II */ 541 skb = alloc_skb((NLMSG_LENGTH(sizeof(*r))) + (RTA_SPACE(iw_buf_len)), 542 GFP_KERNEL); 543 if (!skb) 544 goto out; 545 b = skb->tail; 546 547 /* Put in the message the usual good stuff */ 548 nlh = NLMSG_PUT(skb, NETLINK_CB(in_skb).pid, in_nlh->nlmsg_seq, 549 RTM_NEWLINK, sizeof(*r)); 550 r = NLMSG_DATA(nlh); 551 r->ifi_family = AF_UNSPEC; 552 r->__ifi_pad = 0; 553 r->ifi_type = dev->type; 554 r->ifi_index = dev->ifindex; 555 r->ifi_flags = dev->flags; 556 r->ifi_change = 0; 557 558 /* Put the wireless payload if it exist */ 559 if(iw_buf != NULL) 560 RTA_PUT(skb, IFLA_WIRELESS, iw_buf_len, 561 iw_buf + IW_EV_POINT_OFF); 562 563 nlh->nlmsg_len = skb->tail - b; 564 565 /* Needed ? */ 566 NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid; 567 568 err = netlink_unicast(rtnl, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT); 569 if (err > 0) 570 err = 0; 571 out: 572 if(iw_buf != NULL) 573 kfree(iw_buf); 574 dev_put(dev); 575 return err; 576 577 rtattr_failure: 578 nlmsg_failure: 579 kfree_skb(skb); 580 goto out; 581 } 582 #endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 583 584 static int rtnetlink_dump_all(struct sk_buff *skb, struct netlink_callback *cb) 585 { 586 int idx; 587 int s_idx = cb->family; 588 589 if (s_idx == 0) 590 s_idx = 1; 591 for (idx=1; idx<NPROTO; idx++) { 592 int type = cb->nlh->nlmsg_type-RTM_BASE; 593 if (idx < s_idx || idx == PF_PACKET) 594 continue; 595 if (rtnetlink_links[idx] == NULL || 596 rtnetlink_links[idx][type].dumpit == NULL) 597 continue; 598 if (idx > s_idx) 599 memset(&cb->args[0], 0, sizeof(cb->args)); 600 if (rtnetlink_links[idx][type].dumpit(skb, cb)) 601 break; 602 } 603 cb->family = idx; 604 605 return skb->len; 606 } 607 608 void rtmsg_ifinfo(int type, struct net_device *dev, unsigned change) 609 { 610 struct sk_buff *skb; 611 int size = NLMSG_SPACE(sizeof(struct ifinfomsg) + 612 sizeof(struct rtnl_link_ifmap) + 613 sizeof(struct rtnl_link_stats) + 128); 614 615 skb = alloc_skb(size, GFP_KERNEL); 616 if (!skb) 617 return; 618 619 if (rtnetlink_fill_ifinfo(skb, dev, type, 0, 0, change, 0) < 0) { 620 kfree_skb(skb); 621 return; 622 } 623 NETLINK_CB(skb).dst_group = RTNLGRP_LINK; 624 netlink_broadcast(rtnl, skb, 0, RTNLGRP_LINK, GFP_KERNEL); 625 } 626 627 /* Protected by RTNL sempahore. */ 628 static struct rtattr **rta_buf; 629 static int rtattr_max; 630 631 /* Process one rtnetlink message. */ 632 633 static __inline__ int 634 rtnetlink_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh, int *errp) 635 { 636 struct rtnetlink_link *link; 637 struct rtnetlink_link *link_tab; 638 int sz_idx, kind; 639 int min_len; 640 int family; 641 int type; 642 int err; 643 644 /* Only requests are handled by kernel now */ 645 if (!(nlh->nlmsg_flags&NLM_F_REQUEST)) 646 return 0; 647 648 type = nlh->nlmsg_type; 649 650 /* A control message: ignore them */ 651 if (type < RTM_BASE) 652 return 0; 653 654 /* Unknown message: reply with EINVAL */ 655 if (type > RTM_MAX) 656 goto err_inval; 657 658 type -= RTM_BASE; 659 660 /* All the messages must have at least 1 byte length */ 661 if (nlh->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtgenmsg))) 662 return 0; 663 664 family = ((struct rtgenmsg*)NLMSG_DATA(nlh))->rtgen_family; 665 if (family >= NPROTO) { 666 *errp = -EAFNOSUPPORT; 667 return -1; 668 } 669 670 link_tab = rtnetlink_links[family]; 671 if (link_tab == NULL) 672 link_tab = rtnetlink_links[PF_UNSPEC]; 673 link = &link_tab[type]; 674 675 sz_idx = type>>2; 676 kind = type&3; 677 678 if (kind != 2 && security_netlink_recv(skb, CAP_NET_ADMIN)) { 679 *errp = -EPERM; 680 return -1; 681 } 682 683 if (kind == 2 && nlh->nlmsg_flags&NLM_F_DUMP) { 684 if (link->dumpit == NULL) 685 link = &(rtnetlink_links[PF_UNSPEC][type]); 686 687 if (link->dumpit == NULL) 688 goto err_inval; 689 690 if ((*errp = netlink_dump_start(rtnl, skb, nlh, 691 link->dumpit, NULL)) != 0) { 692 return -1; 693 } 694 695 netlink_queue_skip(nlh, skb); 696 return -1; 697 } 698 699 memset(rta_buf, 0, (rtattr_max * sizeof(struct rtattr *))); 700 701 min_len = rtm_min[sz_idx]; 702 if (nlh->nlmsg_len < min_len) 703 goto err_inval; 704 705 if (nlh->nlmsg_len > min_len) { 706 int attrlen = nlh->nlmsg_len - NLMSG_ALIGN(min_len); 707 struct rtattr *attr = (void*)nlh + NLMSG_ALIGN(min_len); 708 709 while (RTA_OK(attr, attrlen)) { 710 unsigned flavor = attr->rta_type; 711 if (flavor) { 712 if (flavor > rta_max[sz_idx]) 713 goto err_inval; 714 rta_buf[flavor-1] = attr; 715 } 716 attr = RTA_NEXT(attr, attrlen); 717 } 718 } 719 720 if (link->doit == NULL) 721 link = &(rtnetlink_links[PF_UNSPEC][type]); 722 if (link->doit == NULL) 723 goto err_inval; 724 err = link->doit(skb, nlh, (void *)&rta_buf[0]); 725 726 *errp = err; 727 return err; 728 729 err_inval: 730 *errp = -EINVAL; 731 return -1; 732 } 733 734 static void rtnetlink_rcv(struct sock *sk, int len) 735 { 736 unsigned int qlen = 0; 737 738 do { 739 mutex_lock(&rtnl_mutex); 740 netlink_run_queue(sk, &qlen, &rtnetlink_rcv_msg); 741 mutex_unlock(&rtnl_mutex); 742 743 netdev_run_todo(); 744 } while (qlen); 745 } 746 747 static struct rtnetlink_link link_rtnetlink_table[RTM_NR_MSGTYPES] = 748 { 749 [RTM_GETLINK - RTM_BASE] = { 750 #ifdef CONFIG_NET_WIRELESS_RTNETLINK 751 .doit = do_getlink, 752 #endif /* CONFIG_NET_WIRELESS_RTNETLINK */ 753 .dumpit = rtnetlink_dump_ifinfo }, 754 [RTM_SETLINK - RTM_BASE] = { .doit = do_setlink }, 755 [RTM_GETADDR - RTM_BASE] = { .dumpit = rtnetlink_dump_all }, 756 [RTM_GETROUTE - RTM_BASE] = { .dumpit = rtnetlink_dump_all }, 757 [RTM_NEWNEIGH - RTM_BASE] = { .doit = neigh_add }, 758 [RTM_DELNEIGH - RTM_BASE] = { .doit = neigh_delete }, 759 [RTM_GETNEIGH - RTM_BASE] = { .dumpit = neigh_dump_info }, 760 [RTM_GETRULE - RTM_BASE] = { .dumpit = rtnetlink_dump_all }, 761 [RTM_GETNEIGHTBL - RTM_BASE] = { .dumpit = neightbl_dump_info }, 762 [RTM_SETNEIGHTBL - RTM_BASE] = { .doit = neightbl_set }, 763 }; 764 765 static int rtnetlink_event(struct notifier_block *this, unsigned long event, void *ptr) 766 { 767 struct net_device *dev = ptr; 768 switch (event) { 769 case NETDEV_UNREGISTER: 770 rtmsg_ifinfo(RTM_DELLINK, dev, ~0U); 771 break; 772 case NETDEV_REGISTER: 773 rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U); 774 break; 775 case NETDEV_UP: 776 case NETDEV_DOWN: 777 rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP|IFF_RUNNING); 778 break; 779 case NETDEV_CHANGE: 780 case NETDEV_GOING_DOWN: 781 break; 782 default: 783 rtmsg_ifinfo(RTM_NEWLINK, dev, 0); 784 break; 785 } 786 return NOTIFY_DONE; 787 } 788 789 static struct notifier_block rtnetlink_dev_notifier = { 790 .notifier_call = rtnetlink_event, 791 }; 792 793 void __init rtnetlink_init(void) 794 { 795 int i; 796 797 rtattr_max = 0; 798 for (i = 0; i < ARRAY_SIZE(rta_max); i++) 799 if (rta_max[i] > rtattr_max) 800 rtattr_max = rta_max[i]; 801 rta_buf = kmalloc(rtattr_max * sizeof(struct rtattr *), GFP_KERNEL); 802 if (!rta_buf) 803 panic("rtnetlink_init: cannot allocate rta_buf\n"); 804 805 rtnl = netlink_kernel_create(NETLINK_ROUTE, RTNLGRP_MAX, rtnetlink_rcv, 806 THIS_MODULE); 807 if (rtnl == NULL) 808 panic("rtnetlink_init: cannot initialize rtnetlink\n"); 809 netlink_set_nonroot(NETLINK_ROUTE, NL_NONROOT_RECV); 810 register_netdevice_notifier(&rtnetlink_dev_notifier); 811 rtnetlink_links[PF_UNSPEC] = link_rtnetlink_table; 812 rtnetlink_links[PF_PACKET] = link_rtnetlink_table; 813 } 814 815 EXPORT_SYMBOL(__rta_fill); 816 EXPORT_SYMBOL(rtattr_strlcpy); 817 EXPORT_SYMBOL(rtattr_parse); 818 EXPORT_SYMBOL(rtnetlink_links); 819 EXPORT_SYMBOL(rtnetlink_put_metrics); 820 EXPORT_SYMBOL(rtnl); 821 EXPORT_SYMBOL(rtnl_lock); 822 EXPORT_SYMBOL(rtnl_trylock); 823 EXPORT_SYMBOL(rtnl_unlock); 824