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