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