1 /* 2 * IEEE802154.4 socket interface 3 * 4 * Copyright 2007, 2008 Siemens AG 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 8 * as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * Written by: 16 * Sergey Lapin <slapin@ossfans.org> 17 * Maxim Gorbachyov <maxim.gorbachev@siemens.com> 18 */ 19 20 #include <linux/net.h> 21 #include <linux/capability.h> 22 #include <linux/module.h> 23 #include <linux/if_arp.h> 24 #include <linux/if.h> 25 #include <linux/termios.h> /* For TIOCOUTQ/INQ */ 26 #include <linux/list.h> 27 #include <linux/slab.h> 28 #include <net/datalink.h> 29 #include <net/psnap.h> 30 #include <net/sock.h> 31 #include <net/tcp_states.h> 32 #include <net/route.h> 33 34 #include <net/af_ieee802154.h> 35 #include <net/ieee802154_netdev.h> 36 37 /* Utility function for families */ 38 static struct net_device* 39 ieee802154_get_dev(struct net *net, const struct ieee802154_addr *addr) 40 { 41 struct net_device *dev = NULL; 42 struct net_device *tmp; 43 __le16 pan_id, short_addr; 44 u8 hwaddr[IEEE802154_ADDR_LEN]; 45 46 switch (addr->mode) { 47 case IEEE802154_ADDR_LONG: 48 ieee802154_devaddr_to_raw(hwaddr, addr->extended_addr); 49 rcu_read_lock(); 50 dev = dev_getbyhwaddr_rcu(net, ARPHRD_IEEE802154, hwaddr); 51 if (dev) 52 dev_hold(dev); 53 rcu_read_unlock(); 54 break; 55 case IEEE802154_ADDR_SHORT: 56 if (addr->pan_id == cpu_to_le16(IEEE802154_PANID_BROADCAST) || 57 addr->short_addr == cpu_to_le16(IEEE802154_ADDR_UNDEF) || 58 addr->short_addr == cpu_to_le16(IEEE802154_ADDR_BROADCAST)) 59 break; 60 61 rtnl_lock(); 62 63 for_each_netdev(net, tmp) { 64 if (tmp->type != ARPHRD_IEEE802154) 65 continue; 66 67 pan_id = tmp->ieee802154_ptr->pan_id; 68 short_addr = tmp->ieee802154_ptr->short_addr; 69 if (pan_id == addr->pan_id && 70 short_addr == addr->short_addr) { 71 dev = tmp; 72 dev_hold(dev); 73 break; 74 } 75 } 76 77 rtnl_unlock(); 78 break; 79 default: 80 pr_warn("Unsupported ieee802154 address type: %d\n", 81 addr->mode); 82 break; 83 } 84 85 return dev; 86 } 87 88 static int ieee802154_sock_release(struct socket *sock) 89 { 90 struct sock *sk = sock->sk; 91 92 if (sk) { 93 sock->sk = NULL; 94 sk->sk_prot->close(sk, 0); 95 } 96 return 0; 97 } 98 99 static int ieee802154_sock_sendmsg(struct socket *sock, struct msghdr *msg, 100 size_t len) 101 { 102 struct sock *sk = sock->sk; 103 104 return sk->sk_prot->sendmsg(sk, msg, len); 105 } 106 107 static int ieee802154_sock_bind(struct socket *sock, struct sockaddr *uaddr, 108 int addr_len) 109 { 110 struct sock *sk = sock->sk; 111 112 if (sk->sk_prot->bind) 113 return sk->sk_prot->bind(sk, uaddr, addr_len); 114 115 return sock_no_bind(sock, uaddr, addr_len); 116 } 117 118 static int ieee802154_sock_connect(struct socket *sock, struct sockaddr *uaddr, 119 int addr_len, int flags) 120 { 121 struct sock *sk = sock->sk; 122 123 if (addr_len < sizeof(uaddr->sa_family)) 124 return -EINVAL; 125 126 if (uaddr->sa_family == AF_UNSPEC) 127 return sk->sk_prot->disconnect(sk, flags); 128 129 return sk->sk_prot->connect(sk, uaddr, addr_len); 130 } 131 132 static int ieee802154_dev_ioctl(struct sock *sk, struct ifreq __user *arg, 133 unsigned int cmd) 134 { 135 struct ifreq ifr; 136 int ret = -ENOIOCTLCMD; 137 struct net_device *dev; 138 139 if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) 140 return -EFAULT; 141 142 ifr.ifr_name[IFNAMSIZ-1] = 0; 143 144 dev_load(sock_net(sk), ifr.ifr_name); 145 dev = dev_get_by_name(sock_net(sk), ifr.ifr_name); 146 147 if (!dev) 148 return -ENODEV; 149 150 if (dev->type == ARPHRD_IEEE802154 && dev->netdev_ops->ndo_do_ioctl) 151 ret = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, cmd); 152 153 if (!ret && copy_to_user(arg, &ifr, sizeof(struct ifreq))) 154 ret = -EFAULT; 155 dev_put(dev); 156 157 return ret; 158 } 159 160 static int ieee802154_sock_ioctl(struct socket *sock, unsigned int cmd, 161 unsigned long arg) 162 { 163 struct sock *sk = sock->sk; 164 165 switch (cmd) { 166 case SIOCGSTAMP: 167 return sock_get_timestamp(sk, (struct timeval __user *)arg); 168 case SIOCGSTAMPNS: 169 return sock_get_timestampns(sk, (struct timespec __user *)arg); 170 case SIOCGIFADDR: 171 case SIOCSIFADDR: 172 return ieee802154_dev_ioctl(sk, (struct ifreq __user *)arg, 173 cmd); 174 default: 175 if (!sk->sk_prot->ioctl) 176 return -ENOIOCTLCMD; 177 return sk->sk_prot->ioctl(sk, cmd, arg); 178 } 179 } 180 181 /* RAW Sockets (802.15.4 created in userspace) */ 182 static HLIST_HEAD(raw_head); 183 static DEFINE_RWLOCK(raw_lock); 184 185 static void raw_hash(struct sock *sk) 186 { 187 write_lock_bh(&raw_lock); 188 sk_add_node(sk, &raw_head); 189 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1); 190 write_unlock_bh(&raw_lock); 191 } 192 193 static void raw_unhash(struct sock *sk) 194 { 195 write_lock_bh(&raw_lock); 196 if (sk_del_node_init(sk)) 197 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1); 198 write_unlock_bh(&raw_lock); 199 } 200 201 static void raw_close(struct sock *sk, long timeout) 202 { 203 sk_common_release(sk); 204 } 205 206 static int raw_bind(struct sock *sk, struct sockaddr *_uaddr, int len) 207 { 208 struct ieee802154_addr addr; 209 struct sockaddr_ieee802154 *uaddr = (struct sockaddr_ieee802154 *)_uaddr; 210 int err = 0; 211 struct net_device *dev = NULL; 212 213 if (len < sizeof(*uaddr)) 214 return -EINVAL; 215 216 uaddr = (struct sockaddr_ieee802154 *)_uaddr; 217 if (uaddr->family != AF_IEEE802154) 218 return -EINVAL; 219 220 lock_sock(sk); 221 222 ieee802154_addr_from_sa(&addr, &uaddr->addr); 223 dev = ieee802154_get_dev(sock_net(sk), &addr); 224 if (!dev) { 225 err = -ENODEV; 226 goto out; 227 } 228 229 sk->sk_bound_dev_if = dev->ifindex; 230 sk_dst_reset(sk); 231 232 dev_put(dev); 233 out: 234 release_sock(sk); 235 236 return err; 237 } 238 239 static int raw_connect(struct sock *sk, struct sockaddr *uaddr, 240 int addr_len) 241 { 242 return -ENOTSUPP; 243 } 244 245 static int raw_disconnect(struct sock *sk, int flags) 246 { 247 return 0; 248 } 249 250 static int raw_sendmsg(struct sock *sk, struct msghdr *msg, size_t size) 251 { 252 struct net_device *dev; 253 unsigned int mtu; 254 struct sk_buff *skb; 255 int hlen, tlen; 256 int err; 257 258 if (msg->msg_flags & MSG_OOB) { 259 pr_debug("msg->msg_flags = 0x%x\n", msg->msg_flags); 260 return -EOPNOTSUPP; 261 } 262 263 lock_sock(sk); 264 if (!sk->sk_bound_dev_if) 265 dev = dev_getfirstbyhwtype(sock_net(sk), ARPHRD_IEEE802154); 266 else 267 dev = dev_get_by_index(sock_net(sk), sk->sk_bound_dev_if); 268 release_sock(sk); 269 270 if (!dev) { 271 pr_debug("no dev\n"); 272 err = -ENXIO; 273 goto out; 274 } 275 276 mtu = dev->mtu; 277 pr_debug("name = %s, mtu = %u\n", dev->name, mtu); 278 279 if (size > mtu) { 280 pr_debug("size = %Zu, mtu = %u\n", size, mtu); 281 err = -EMSGSIZE; 282 goto out_dev; 283 } 284 285 hlen = LL_RESERVED_SPACE(dev); 286 tlen = dev->needed_tailroom; 287 skb = sock_alloc_send_skb(sk, hlen + tlen + size, 288 msg->msg_flags & MSG_DONTWAIT, &err); 289 if (!skb) 290 goto out_dev; 291 292 skb_reserve(skb, hlen); 293 294 skb_reset_mac_header(skb); 295 skb_reset_network_header(skb); 296 297 err = memcpy_from_msg(skb_put(skb, size), msg, size); 298 if (err < 0) 299 goto out_skb; 300 301 skb->dev = dev; 302 skb->sk = sk; 303 skb->protocol = htons(ETH_P_IEEE802154); 304 305 dev_put(dev); 306 307 err = dev_queue_xmit(skb); 308 if (err > 0) 309 err = net_xmit_errno(err); 310 311 return err ?: size; 312 313 out_skb: 314 kfree_skb(skb); 315 out_dev: 316 dev_put(dev); 317 out: 318 return err; 319 } 320 321 static int raw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 322 int noblock, int flags, int *addr_len) 323 { 324 size_t copied = 0; 325 int err = -EOPNOTSUPP; 326 struct sk_buff *skb; 327 328 skb = skb_recv_datagram(sk, flags, noblock, &err); 329 if (!skb) 330 goto out; 331 332 copied = skb->len; 333 if (len < copied) { 334 msg->msg_flags |= MSG_TRUNC; 335 copied = len; 336 } 337 338 err = skb_copy_datagram_msg(skb, 0, msg, copied); 339 if (err) 340 goto done; 341 342 sock_recv_ts_and_drops(msg, sk, skb); 343 344 if (flags & MSG_TRUNC) 345 copied = skb->len; 346 done: 347 skb_free_datagram(sk, skb); 348 out: 349 if (err) 350 return err; 351 return copied; 352 } 353 354 static int raw_rcv_skb(struct sock *sk, struct sk_buff *skb) 355 { 356 skb = skb_share_check(skb, GFP_ATOMIC); 357 if (!skb) 358 return NET_RX_DROP; 359 360 if (sock_queue_rcv_skb(sk, skb) < 0) { 361 kfree_skb(skb); 362 return NET_RX_DROP; 363 } 364 365 return NET_RX_SUCCESS; 366 } 367 368 static void ieee802154_raw_deliver(struct net_device *dev, struct sk_buff *skb) 369 { 370 struct sock *sk; 371 372 read_lock(&raw_lock); 373 sk_for_each(sk, &raw_head) { 374 bh_lock_sock(sk); 375 if (!sk->sk_bound_dev_if || 376 sk->sk_bound_dev_if == dev->ifindex) { 377 struct sk_buff *clone; 378 379 clone = skb_clone(skb, GFP_ATOMIC); 380 if (clone) 381 raw_rcv_skb(sk, clone); 382 } 383 bh_unlock_sock(sk); 384 } 385 read_unlock(&raw_lock); 386 } 387 388 static int raw_getsockopt(struct sock *sk, int level, int optname, 389 char __user *optval, int __user *optlen) 390 { 391 return -EOPNOTSUPP; 392 } 393 394 static int raw_setsockopt(struct sock *sk, int level, int optname, 395 char __user *optval, unsigned int optlen) 396 { 397 return -EOPNOTSUPP; 398 } 399 400 static struct proto ieee802154_raw_prot = { 401 .name = "IEEE-802.15.4-RAW", 402 .owner = THIS_MODULE, 403 .obj_size = sizeof(struct sock), 404 .close = raw_close, 405 .bind = raw_bind, 406 .sendmsg = raw_sendmsg, 407 .recvmsg = raw_recvmsg, 408 .hash = raw_hash, 409 .unhash = raw_unhash, 410 .connect = raw_connect, 411 .disconnect = raw_disconnect, 412 .getsockopt = raw_getsockopt, 413 .setsockopt = raw_setsockopt, 414 }; 415 416 static const struct proto_ops ieee802154_raw_ops = { 417 .family = PF_IEEE802154, 418 .owner = THIS_MODULE, 419 .release = ieee802154_sock_release, 420 .bind = ieee802154_sock_bind, 421 .connect = ieee802154_sock_connect, 422 .socketpair = sock_no_socketpair, 423 .accept = sock_no_accept, 424 .getname = sock_no_getname, 425 .poll = datagram_poll, 426 .ioctl = ieee802154_sock_ioctl, 427 .listen = sock_no_listen, 428 .shutdown = sock_no_shutdown, 429 .setsockopt = sock_common_setsockopt, 430 .getsockopt = sock_common_getsockopt, 431 .sendmsg = ieee802154_sock_sendmsg, 432 .recvmsg = sock_common_recvmsg, 433 .mmap = sock_no_mmap, 434 .sendpage = sock_no_sendpage, 435 #ifdef CONFIG_COMPAT 436 .compat_setsockopt = compat_sock_common_setsockopt, 437 .compat_getsockopt = compat_sock_common_getsockopt, 438 #endif 439 }; 440 441 /* DGRAM Sockets (802.15.4 dataframes) */ 442 static HLIST_HEAD(dgram_head); 443 static DEFINE_RWLOCK(dgram_lock); 444 445 struct dgram_sock { 446 struct sock sk; 447 448 struct ieee802154_addr src_addr; 449 struct ieee802154_addr dst_addr; 450 451 unsigned int bound:1; 452 unsigned int connected:1; 453 unsigned int want_ack:1; 454 unsigned int secen:1; 455 unsigned int secen_override:1; 456 unsigned int seclevel:3; 457 unsigned int seclevel_override:1; 458 }; 459 460 static inline struct dgram_sock *dgram_sk(const struct sock *sk) 461 { 462 return container_of(sk, struct dgram_sock, sk); 463 } 464 465 static void dgram_hash(struct sock *sk) 466 { 467 write_lock_bh(&dgram_lock); 468 sk_add_node(sk, &dgram_head); 469 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1); 470 write_unlock_bh(&dgram_lock); 471 } 472 473 static void dgram_unhash(struct sock *sk) 474 { 475 write_lock_bh(&dgram_lock); 476 if (sk_del_node_init(sk)) 477 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1); 478 write_unlock_bh(&dgram_lock); 479 } 480 481 static int dgram_init(struct sock *sk) 482 { 483 struct dgram_sock *ro = dgram_sk(sk); 484 485 ro->want_ack = 1; 486 return 0; 487 } 488 489 static void dgram_close(struct sock *sk, long timeout) 490 { 491 sk_common_release(sk); 492 } 493 494 static int dgram_bind(struct sock *sk, struct sockaddr *uaddr, int len) 495 { 496 struct sockaddr_ieee802154 *addr = (struct sockaddr_ieee802154 *)uaddr; 497 struct ieee802154_addr haddr; 498 struct dgram_sock *ro = dgram_sk(sk); 499 int err = -EINVAL; 500 struct net_device *dev; 501 502 lock_sock(sk); 503 504 ro->bound = 0; 505 506 if (len < sizeof(*addr)) 507 goto out; 508 509 if (addr->family != AF_IEEE802154) 510 goto out; 511 512 ieee802154_addr_from_sa(&haddr, &addr->addr); 513 dev = ieee802154_get_dev(sock_net(sk), &haddr); 514 if (!dev) { 515 err = -ENODEV; 516 goto out; 517 } 518 519 if (dev->type != ARPHRD_IEEE802154) { 520 err = -ENODEV; 521 goto out_put; 522 } 523 524 ro->src_addr = haddr; 525 526 ro->bound = 1; 527 err = 0; 528 out_put: 529 dev_put(dev); 530 out: 531 release_sock(sk); 532 533 return err; 534 } 535 536 static int dgram_ioctl(struct sock *sk, int cmd, unsigned long arg) 537 { 538 switch (cmd) { 539 case SIOCOUTQ: 540 { 541 int amount = sk_wmem_alloc_get(sk); 542 543 return put_user(amount, (int __user *)arg); 544 } 545 546 case SIOCINQ: 547 { 548 struct sk_buff *skb; 549 unsigned long amount; 550 551 amount = 0; 552 spin_lock_bh(&sk->sk_receive_queue.lock); 553 skb = skb_peek(&sk->sk_receive_queue); 554 if (skb) { 555 /* We will only return the amount 556 * of this packet since that is all 557 * that will be read. 558 */ 559 amount = skb->len - ieee802154_hdr_length(skb); 560 } 561 spin_unlock_bh(&sk->sk_receive_queue.lock); 562 return put_user(amount, (int __user *)arg); 563 } 564 } 565 566 return -ENOIOCTLCMD; 567 } 568 569 /* FIXME: autobind */ 570 static int dgram_connect(struct sock *sk, struct sockaddr *uaddr, 571 int len) 572 { 573 struct sockaddr_ieee802154 *addr = (struct sockaddr_ieee802154 *)uaddr; 574 struct dgram_sock *ro = dgram_sk(sk); 575 int err = 0; 576 577 if (len < sizeof(*addr)) 578 return -EINVAL; 579 580 if (addr->family != AF_IEEE802154) 581 return -EINVAL; 582 583 lock_sock(sk); 584 585 if (!ro->bound) { 586 err = -ENETUNREACH; 587 goto out; 588 } 589 590 ieee802154_addr_from_sa(&ro->dst_addr, &addr->addr); 591 ro->connected = 1; 592 593 out: 594 release_sock(sk); 595 return err; 596 } 597 598 static int dgram_disconnect(struct sock *sk, int flags) 599 { 600 struct dgram_sock *ro = dgram_sk(sk); 601 602 lock_sock(sk); 603 ro->connected = 0; 604 release_sock(sk); 605 606 return 0; 607 } 608 609 static int dgram_sendmsg(struct sock *sk, struct msghdr *msg, size_t size) 610 { 611 struct net_device *dev; 612 unsigned int mtu; 613 struct sk_buff *skb; 614 struct ieee802154_mac_cb *cb; 615 struct dgram_sock *ro = dgram_sk(sk); 616 struct ieee802154_addr dst_addr; 617 int hlen, tlen; 618 int err; 619 620 if (msg->msg_flags & MSG_OOB) { 621 pr_debug("msg->msg_flags = 0x%x\n", msg->msg_flags); 622 return -EOPNOTSUPP; 623 } 624 625 if (!ro->connected && !msg->msg_name) 626 return -EDESTADDRREQ; 627 else if (ro->connected && msg->msg_name) 628 return -EISCONN; 629 630 if (!ro->bound) 631 dev = dev_getfirstbyhwtype(sock_net(sk), ARPHRD_IEEE802154); 632 else 633 dev = ieee802154_get_dev(sock_net(sk), &ro->src_addr); 634 635 if (!dev) { 636 pr_debug("no dev\n"); 637 err = -ENXIO; 638 goto out; 639 } 640 mtu = dev->mtu; 641 pr_debug("name = %s, mtu = %u\n", dev->name, mtu); 642 643 if (size > mtu) { 644 pr_debug("size = %Zu, mtu = %u\n", size, mtu); 645 err = -EMSGSIZE; 646 goto out_dev; 647 } 648 649 hlen = LL_RESERVED_SPACE(dev); 650 tlen = dev->needed_tailroom; 651 skb = sock_alloc_send_skb(sk, hlen + tlen + size, 652 msg->msg_flags & MSG_DONTWAIT, 653 &err); 654 if (!skb) 655 goto out_dev; 656 657 skb_reserve(skb, hlen); 658 659 skb_reset_network_header(skb); 660 661 cb = mac_cb_init(skb); 662 cb->type = IEEE802154_FC_TYPE_DATA; 663 cb->ackreq = ro->want_ack; 664 665 if (msg->msg_name) { 666 DECLARE_SOCKADDR(struct sockaddr_ieee802154*, 667 daddr, msg->msg_name); 668 669 ieee802154_addr_from_sa(&dst_addr, &daddr->addr); 670 } else { 671 dst_addr = ro->dst_addr; 672 } 673 674 cb->secen = ro->secen; 675 cb->secen_override = ro->secen_override; 676 cb->seclevel = ro->seclevel; 677 cb->seclevel_override = ro->seclevel_override; 678 679 err = dev_hard_header(skb, dev, ETH_P_IEEE802154, &dst_addr, 680 ro->bound ? &ro->src_addr : NULL, size); 681 if (err < 0) 682 goto out_skb; 683 684 err = memcpy_from_msg(skb_put(skb, size), msg, size); 685 if (err < 0) 686 goto out_skb; 687 688 skb->dev = dev; 689 skb->sk = sk; 690 skb->protocol = htons(ETH_P_IEEE802154); 691 692 dev_put(dev); 693 694 err = dev_queue_xmit(skb); 695 if (err > 0) 696 err = net_xmit_errno(err); 697 698 return err ?: size; 699 700 out_skb: 701 kfree_skb(skb); 702 out_dev: 703 dev_put(dev); 704 out: 705 return err; 706 } 707 708 static int dgram_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 709 int noblock, int flags, int *addr_len) 710 { 711 size_t copied = 0; 712 int err = -EOPNOTSUPP; 713 struct sk_buff *skb; 714 DECLARE_SOCKADDR(struct sockaddr_ieee802154 *, saddr, msg->msg_name); 715 716 skb = skb_recv_datagram(sk, flags, noblock, &err); 717 if (!skb) 718 goto out; 719 720 copied = skb->len; 721 if (len < copied) { 722 msg->msg_flags |= MSG_TRUNC; 723 copied = len; 724 } 725 726 /* FIXME: skip headers if necessary ?! */ 727 err = skb_copy_datagram_msg(skb, 0, msg, copied); 728 if (err) 729 goto done; 730 731 sock_recv_ts_and_drops(msg, sk, skb); 732 733 if (saddr) { 734 saddr->family = AF_IEEE802154; 735 ieee802154_addr_to_sa(&saddr->addr, &mac_cb(skb)->source); 736 *addr_len = sizeof(*saddr); 737 } 738 739 if (flags & MSG_TRUNC) 740 copied = skb->len; 741 done: 742 skb_free_datagram(sk, skb); 743 out: 744 if (err) 745 return err; 746 return copied; 747 } 748 749 static int dgram_rcv_skb(struct sock *sk, struct sk_buff *skb) 750 { 751 skb = skb_share_check(skb, GFP_ATOMIC); 752 if (!skb) 753 return NET_RX_DROP; 754 755 if (sock_queue_rcv_skb(sk, skb) < 0) { 756 kfree_skb(skb); 757 return NET_RX_DROP; 758 } 759 760 return NET_RX_SUCCESS; 761 } 762 763 static inline bool 764 ieee802154_match_sock(__le64 hw_addr, __le16 pan_id, __le16 short_addr, 765 struct dgram_sock *ro) 766 { 767 if (!ro->bound) 768 return true; 769 770 if (ro->src_addr.mode == IEEE802154_ADDR_LONG && 771 hw_addr == ro->src_addr.extended_addr) 772 return true; 773 774 if (ro->src_addr.mode == IEEE802154_ADDR_SHORT && 775 pan_id == ro->src_addr.pan_id && 776 short_addr == ro->src_addr.short_addr) 777 return true; 778 779 return false; 780 } 781 782 static int ieee802154_dgram_deliver(struct net_device *dev, struct sk_buff *skb) 783 { 784 struct sock *sk, *prev = NULL; 785 int ret = NET_RX_SUCCESS; 786 __le16 pan_id, short_addr; 787 __le64 hw_addr; 788 789 /* Data frame processing */ 790 BUG_ON(dev->type != ARPHRD_IEEE802154); 791 792 pan_id = dev->ieee802154_ptr->pan_id; 793 short_addr = dev->ieee802154_ptr->short_addr; 794 hw_addr = dev->ieee802154_ptr->extended_addr; 795 796 read_lock(&dgram_lock); 797 sk_for_each(sk, &dgram_head) { 798 if (ieee802154_match_sock(hw_addr, pan_id, short_addr, 799 dgram_sk(sk))) { 800 if (prev) { 801 struct sk_buff *clone; 802 803 clone = skb_clone(skb, GFP_ATOMIC); 804 if (clone) 805 dgram_rcv_skb(prev, clone); 806 } 807 808 prev = sk; 809 } 810 } 811 812 if (prev) { 813 dgram_rcv_skb(prev, skb); 814 } else { 815 kfree_skb(skb); 816 ret = NET_RX_DROP; 817 } 818 read_unlock(&dgram_lock); 819 820 return ret; 821 } 822 823 static int dgram_getsockopt(struct sock *sk, int level, int optname, 824 char __user *optval, int __user *optlen) 825 { 826 struct dgram_sock *ro = dgram_sk(sk); 827 828 int val, len; 829 830 if (level != SOL_IEEE802154) 831 return -EOPNOTSUPP; 832 833 if (get_user(len, optlen)) 834 return -EFAULT; 835 836 len = min_t(unsigned int, len, sizeof(int)); 837 838 switch (optname) { 839 case WPAN_WANTACK: 840 val = ro->want_ack; 841 break; 842 case WPAN_SECURITY: 843 if (!ro->secen_override) 844 val = WPAN_SECURITY_DEFAULT; 845 else if (ro->secen) 846 val = WPAN_SECURITY_ON; 847 else 848 val = WPAN_SECURITY_OFF; 849 break; 850 case WPAN_SECURITY_LEVEL: 851 if (!ro->seclevel_override) 852 val = WPAN_SECURITY_LEVEL_DEFAULT; 853 else 854 val = ro->seclevel; 855 break; 856 default: 857 return -ENOPROTOOPT; 858 } 859 860 if (put_user(len, optlen)) 861 return -EFAULT; 862 if (copy_to_user(optval, &val, len)) 863 return -EFAULT; 864 return 0; 865 } 866 867 static int dgram_setsockopt(struct sock *sk, int level, int optname, 868 char __user *optval, unsigned int optlen) 869 { 870 struct dgram_sock *ro = dgram_sk(sk); 871 struct net *net = sock_net(sk); 872 int val; 873 int err = 0; 874 875 if (optlen < sizeof(int)) 876 return -EINVAL; 877 878 if (get_user(val, (int __user *)optval)) 879 return -EFAULT; 880 881 lock_sock(sk); 882 883 switch (optname) { 884 case WPAN_WANTACK: 885 ro->want_ack = !!val; 886 break; 887 case WPAN_SECURITY: 888 if (!ns_capable(net->user_ns, CAP_NET_ADMIN) && 889 !ns_capable(net->user_ns, CAP_NET_RAW)) { 890 err = -EPERM; 891 break; 892 } 893 894 switch (val) { 895 case WPAN_SECURITY_DEFAULT: 896 ro->secen_override = 0; 897 break; 898 case WPAN_SECURITY_ON: 899 ro->secen_override = 1; 900 ro->secen = 1; 901 break; 902 case WPAN_SECURITY_OFF: 903 ro->secen_override = 1; 904 ro->secen = 0; 905 break; 906 default: 907 err = -EINVAL; 908 break; 909 } 910 break; 911 case WPAN_SECURITY_LEVEL: 912 if (!ns_capable(net->user_ns, CAP_NET_ADMIN) && 913 !ns_capable(net->user_ns, CAP_NET_RAW)) { 914 err = -EPERM; 915 break; 916 } 917 918 if (val < WPAN_SECURITY_LEVEL_DEFAULT || 919 val > IEEE802154_SCF_SECLEVEL_ENC_MIC128) { 920 err = -EINVAL; 921 } else if (val == WPAN_SECURITY_LEVEL_DEFAULT) { 922 ro->seclevel_override = 0; 923 } else { 924 ro->seclevel_override = 1; 925 ro->seclevel = val; 926 } 927 break; 928 default: 929 err = -ENOPROTOOPT; 930 break; 931 } 932 933 release_sock(sk); 934 return err; 935 } 936 937 static struct proto ieee802154_dgram_prot = { 938 .name = "IEEE-802.15.4-MAC", 939 .owner = THIS_MODULE, 940 .obj_size = sizeof(struct dgram_sock), 941 .init = dgram_init, 942 .close = dgram_close, 943 .bind = dgram_bind, 944 .sendmsg = dgram_sendmsg, 945 .recvmsg = dgram_recvmsg, 946 .hash = dgram_hash, 947 .unhash = dgram_unhash, 948 .connect = dgram_connect, 949 .disconnect = dgram_disconnect, 950 .ioctl = dgram_ioctl, 951 .getsockopt = dgram_getsockopt, 952 .setsockopt = dgram_setsockopt, 953 }; 954 955 static const struct proto_ops ieee802154_dgram_ops = { 956 .family = PF_IEEE802154, 957 .owner = THIS_MODULE, 958 .release = ieee802154_sock_release, 959 .bind = ieee802154_sock_bind, 960 .connect = ieee802154_sock_connect, 961 .socketpair = sock_no_socketpair, 962 .accept = sock_no_accept, 963 .getname = sock_no_getname, 964 .poll = datagram_poll, 965 .ioctl = ieee802154_sock_ioctl, 966 .listen = sock_no_listen, 967 .shutdown = sock_no_shutdown, 968 .setsockopt = sock_common_setsockopt, 969 .getsockopt = sock_common_getsockopt, 970 .sendmsg = ieee802154_sock_sendmsg, 971 .recvmsg = sock_common_recvmsg, 972 .mmap = sock_no_mmap, 973 .sendpage = sock_no_sendpage, 974 #ifdef CONFIG_COMPAT 975 .compat_setsockopt = compat_sock_common_setsockopt, 976 .compat_getsockopt = compat_sock_common_getsockopt, 977 #endif 978 }; 979 980 /* Create a socket. Initialise the socket, blank the addresses 981 * set the state. 982 */ 983 static int ieee802154_create(struct net *net, struct socket *sock, 984 int protocol, int kern) 985 { 986 struct sock *sk; 987 int rc; 988 struct proto *proto; 989 const struct proto_ops *ops; 990 991 if (!net_eq(net, &init_net)) 992 return -EAFNOSUPPORT; 993 994 switch (sock->type) { 995 case SOCK_RAW: 996 proto = &ieee802154_raw_prot; 997 ops = &ieee802154_raw_ops; 998 break; 999 case SOCK_DGRAM: 1000 proto = &ieee802154_dgram_prot; 1001 ops = &ieee802154_dgram_ops; 1002 break; 1003 default: 1004 rc = -ESOCKTNOSUPPORT; 1005 goto out; 1006 } 1007 1008 rc = -ENOMEM; 1009 sk = sk_alloc(net, PF_IEEE802154, GFP_KERNEL, proto, kern); 1010 if (!sk) 1011 goto out; 1012 rc = 0; 1013 1014 sock->ops = ops; 1015 1016 sock_init_data(sock, sk); 1017 /* FIXME: sk->sk_destruct */ 1018 sk->sk_family = PF_IEEE802154; 1019 1020 /* Checksums on by default */ 1021 sock_set_flag(sk, SOCK_ZAPPED); 1022 1023 if (sk->sk_prot->hash) 1024 sk->sk_prot->hash(sk); 1025 1026 if (sk->sk_prot->init) { 1027 rc = sk->sk_prot->init(sk); 1028 if (rc) 1029 sk_common_release(sk); 1030 } 1031 out: 1032 return rc; 1033 } 1034 1035 static const struct net_proto_family ieee802154_family_ops = { 1036 .family = PF_IEEE802154, 1037 .create = ieee802154_create, 1038 .owner = THIS_MODULE, 1039 }; 1040 1041 static int ieee802154_rcv(struct sk_buff *skb, struct net_device *dev, 1042 struct packet_type *pt, struct net_device *orig_dev) 1043 { 1044 if (!netif_running(dev)) 1045 goto drop; 1046 pr_debug("got frame, type %d, dev %p\n", dev->type, dev); 1047 #ifdef DEBUG 1048 print_hex_dump_bytes("ieee802154_rcv ", 1049 DUMP_PREFIX_NONE, skb->data, skb->len); 1050 #endif 1051 1052 if (!net_eq(dev_net(dev), &init_net)) 1053 goto drop; 1054 1055 ieee802154_raw_deliver(dev, skb); 1056 1057 if (dev->type != ARPHRD_IEEE802154) 1058 goto drop; 1059 1060 if (skb->pkt_type != PACKET_OTHERHOST) 1061 return ieee802154_dgram_deliver(dev, skb); 1062 1063 drop: 1064 kfree_skb(skb); 1065 return NET_RX_DROP; 1066 } 1067 1068 static struct packet_type ieee802154_packet_type = { 1069 .type = htons(ETH_P_IEEE802154), 1070 .func = ieee802154_rcv, 1071 }; 1072 1073 static int __init af_ieee802154_init(void) 1074 { 1075 int rc = -EINVAL; 1076 1077 rc = proto_register(&ieee802154_raw_prot, 1); 1078 if (rc) 1079 goto out; 1080 1081 rc = proto_register(&ieee802154_dgram_prot, 1); 1082 if (rc) 1083 goto err_dgram; 1084 1085 /* Tell SOCKET that we are alive */ 1086 rc = sock_register(&ieee802154_family_ops); 1087 if (rc) 1088 goto err_sock; 1089 dev_add_pack(&ieee802154_packet_type); 1090 1091 rc = 0; 1092 goto out; 1093 1094 err_sock: 1095 proto_unregister(&ieee802154_dgram_prot); 1096 err_dgram: 1097 proto_unregister(&ieee802154_raw_prot); 1098 out: 1099 return rc; 1100 } 1101 1102 static void __exit af_ieee802154_remove(void) 1103 { 1104 dev_remove_pack(&ieee802154_packet_type); 1105 sock_unregister(PF_IEEE802154); 1106 proto_unregister(&ieee802154_dgram_prot); 1107 proto_unregister(&ieee802154_raw_prot); 1108 } 1109 1110 module_init(af_ieee802154_init); 1111 module_exit(af_ieee802154_remove); 1112 1113 MODULE_LICENSE("GPL"); 1114 MODULE_ALIAS_NETPROTO(PF_IEEE802154); 1115