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 if (len < sizeof(*uaddr)) 204 return -EINVAL; 205 206 uaddr = (struct sockaddr_ieee802154 *)_uaddr; 207 if (uaddr->family != AF_IEEE802154) 208 return -EINVAL; 209 210 lock_sock(sk); 211 212 ieee802154_addr_from_sa(&addr, &uaddr->addr); 213 dev = ieee802154_get_dev(sock_net(sk), &addr); 214 if (!dev) { 215 err = -ENODEV; 216 goto out; 217 } 218 219 sk->sk_bound_dev_if = dev->ifindex; 220 sk_dst_reset(sk); 221 222 dev_put(dev); 223 out: 224 release_sock(sk); 225 226 return err; 227 } 228 229 static int raw_connect(struct sock *sk, struct sockaddr *uaddr, 230 int addr_len) 231 { 232 return -ENOTSUPP; 233 } 234 235 static int raw_disconnect(struct sock *sk, int flags) 236 { 237 return 0; 238 } 239 240 static int raw_sendmsg(struct sock *sk, struct msghdr *msg, size_t size) 241 { 242 struct net_device *dev; 243 unsigned int mtu; 244 struct sk_buff *skb; 245 int hlen, tlen; 246 int err; 247 248 if (msg->msg_flags & MSG_OOB) { 249 pr_debug("msg->msg_flags = 0x%x\n", msg->msg_flags); 250 return -EOPNOTSUPP; 251 } 252 253 lock_sock(sk); 254 if (!sk->sk_bound_dev_if) 255 dev = dev_getfirstbyhwtype(sock_net(sk), ARPHRD_IEEE802154); 256 else 257 dev = dev_get_by_index(sock_net(sk), sk->sk_bound_dev_if); 258 release_sock(sk); 259 260 if (!dev) { 261 pr_debug("no dev\n"); 262 err = -ENXIO; 263 goto out; 264 } 265 266 mtu = IEEE802154_MTU; 267 pr_debug("name = %s, mtu = %u\n", dev->name, mtu); 268 269 if (size > mtu) { 270 pr_debug("size = %zu, mtu = %u\n", size, mtu); 271 err = -EMSGSIZE; 272 goto out_dev; 273 } 274 275 hlen = LL_RESERVED_SPACE(dev); 276 tlen = dev->needed_tailroom; 277 skb = sock_alloc_send_skb(sk, hlen + tlen + size, 278 msg->msg_flags & MSG_DONTWAIT, &err); 279 if (!skb) 280 goto out_dev; 281 282 skb_reserve(skb, hlen); 283 284 skb_reset_mac_header(skb); 285 skb_reset_network_header(skb); 286 287 err = memcpy_from_msg(skb_put(skb, size), msg, size); 288 if (err < 0) 289 goto out_skb; 290 291 skb->dev = dev; 292 skb->protocol = htons(ETH_P_IEEE802154); 293 294 err = dev_queue_xmit(skb); 295 if (err > 0) 296 err = net_xmit_errno(err); 297 298 dev_put(dev); 299 300 return err ?: size; 301 302 out_skb: 303 kfree_skb(skb); 304 out_dev: 305 dev_put(dev); 306 out: 307 return err; 308 } 309 310 static int raw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 311 int noblock, int flags, int *addr_len) 312 { 313 size_t copied = 0; 314 int err = -EOPNOTSUPP; 315 struct sk_buff *skb; 316 317 flags |= (noblock ? MSG_DONTWAIT : 0); 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_ts_and_drops(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 if (len < sizeof(*addr)) 498 goto out; 499 500 if (addr->family != AF_IEEE802154) 501 goto out; 502 503 ieee802154_addr_from_sa(&haddr, &addr->addr); 504 dev = ieee802154_get_dev(sock_net(sk), &haddr); 505 if (!dev) { 506 err = -ENODEV; 507 goto out; 508 } 509 510 if (dev->type != ARPHRD_IEEE802154) { 511 err = -ENODEV; 512 goto out_put; 513 } 514 515 ro->src_addr = haddr; 516 517 ro->bound = 1; 518 err = 0; 519 out_put: 520 dev_put(dev); 521 out: 522 release_sock(sk); 523 524 return err; 525 } 526 527 static int dgram_ioctl(struct sock *sk, int cmd, unsigned long arg) 528 { 529 switch (cmd) { 530 case SIOCOUTQ: 531 { 532 int amount = sk_wmem_alloc_get(sk); 533 534 return put_user(amount, (int __user *)arg); 535 } 536 537 case SIOCINQ: 538 { 539 struct sk_buff *skb; 540 unsigned long amount; 541 542 amount = 0; 543 spin_lock_bh(&sk->sk_receive_queue.lock); 544 skb = skb_peek(&sk->sk_receive_queue); 545 if (skb) { 546 /* We will only return the amount 547 * of this packet since that is all 548 * that will be read. 549 */ 550 amount = skb->len - ieee802154_hdr_length(skb); 551 } 552 spin_unlock_bh(&sk->sk_receive_queue.lock); 553 return put_user(amount, (int __user *)arg); 554 } 555 } 556 557 return -ENOIOCTLCMD; 558 } 559 560 /* FIXME: autobind */ 561 static int dgram_connect(struct sock *sk, struct sockaddr *uaddr, 562 int len) 563 { 564 struct sockaddr_ieee802154 *addr = (struct sockaddr_ieee802154 *)uaddr; 565 struct dgram_sock *ro = dgram_sk(sk); 566 int err = 0; 567 568 if (len < sizeof(*addr)) 569 return -EINVAL; 570 571 if (addr->family != AF_IEEE802154) 572 return -EINVAL; 573 574 lock_sock(sk); 575 576 if (!ro->bound) { 577 err = -ENETUNREACH; 578 goto out; 579 } 580 581 ieee802154_addr_from_sa(&ro->dst_addr, &addr->addr); 582 ro->connected = 1; 583 584 out: 585 release_sock(sk); 586 return err; 587 } 588 589 static int dgram_disconnect(struct sock *sk, int flags) 590 { 591 struct dgram_sock *ro = dgram_sk(sk); 592 593 lock_sock(sk); 594 ro->connected = 0; 595 release_sock(sk); 596 597 return 0; 598 } 599 600 static int dgram_sendmsg(struct sock *sk, struct msghdr *msg, size_t size) 601 { 602 struct net_device *dev; 603 unsigned int mtu; 604 struct sk_buff *skb; 605 struct ieee802154_mac_cb *cb; 606 struct dgram_sock *ro = dgram_sk(sk); 607 struct ieee802154_addr dst_addr; 608 int hlen, tlen; 609 int err; 610 611 if (msg->msg_flags & MSG_OOB) { 612 pr_debug("msg->msg_flags = 0x%x\n", msg->msg_flags); 613 return -EOPNOTSUPP; 614 } 615 616 if (!ro->connected && !msg->msg_name) 617 return -EDESTADDRREQ; 618 else if (ro->connected && msg->msg_name) 619 return -EISCONN; 620 621 if (!ro->bound) 622 dev = dev_getfirstbyhwtype(sock_net(sk), ARPHRD_IEEE802154); 623 else 624 dev = ieee802154_get_dev(sock_net(sk), &ro->src_addr); 625 626 if (!dev) { 627 pr_debug("no dev\n"); 628 err = -ENXIO; 629 goto out; 630 } 631 mtu = IEEE802154_MTU; 632 pr_debug("name = %s, mtu = %u\n", dev->name, mtu); 633 634 if (size > mtu) { 635 pr_debug("size = %zu, mtu = %u\n", size, mtu); 636 err = -EMSGSIZE; 637 goto out_dev; 638 } 639 640 hlen = LL_RESERVED_SPACE(dev); 641 tlen = dev->needed_tailroom; 642 skb = sock_alloc_send_skb(sk, hlen + tlen + size, 643 msg->msg_flags & MSG_DONTWAIT, 644 &err); 645 if (!skb) 646 goto out_dev; 647 648 skb_reserve(skb, hlen); 649 650 skb_reset_network_header(skb); 651 652 cb = mac_cb_init(skb); 653 cb->type = IEEE802154_FC_TYPE_DATA; 654 cb->ackreq = ro->want_ack; 655 656 if (msg->msg_name) { 657 DECLARE_SOCKADDR(struct sockaddr_ieee802154*, 658 daddr, msg->msg_name); 659 660 ieee802154_addr_from_sa(&dst_addr, &daddr->addr); 661 } else { 662 dst_addr = ro->dst_addr; 663 } 664 665 cb->secen = ro->secen; 666 cb->secen_override = ro->secen_override; 667 cb->seclevel = ro->seclevel; 668 cb->seclevel_override = ro->seclevel_override; 669 670 err = wpan_dev_hard_header(skb, dev, &dst_addr, 671 ro->bound ? &ro->src_addr : NULL, size); 672 if (err < 0) 673 goto out_skb; 674 675 err = memcpy_from_msg(skb_put(skb, size), msg, size); 676 if (err < 0) 677 goto out_skb; 678 679 skb->dev = dev; 680 skb->protocol = htons(ETH_P_IEEE802154); 681 682 err = dev_queue_xmit(skb); 683 if (err > 0) 684 err = net_xmit_errno(err); 685 686 dev_put(dev); 687 688 return err ?: size; 689 690 out_skb: 691 kfree_skb(skb); 692 out_dev: 693 dev_put(dev); 694 out: 695 return err; 696 } 697 698 static int dgram_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, 699 int noblock, int flags, int *addr_len) 700 { 701 size_t copied = 0; 702 int err = -EOPNOTSUPP; 703 struct sk_buff *skb; 704 struct dgram_sock *ro = dgram_sk(sk); 705 DECLARE_SOCKADDR(struct sockaddr_ieee802154 *, saddr, msg->msg_name); 706 707 flags |= (noblock ? MSG_DONTWAIT : 0); 708 skb = skb_recv_datagram(sk, flags, &err); 709 if (!skb) 710 goto out; 711 712 copied = skb->len; 713 if (len < copied) { 714 msg->msg_flags |= MSG_TRUNC; 715 copied = len; 716 } 717 718 /* FIXME: skip headers if necessary ?! */ 719 err = skb_copy_datagram_msg(skb, 0, msg, copied); 720 if (err) 721 goto done; 722 723 sock_recv_ts_and_drops(msg, sk, skb); 724 725 if (saddr) { 726 /* Clear the implicit padding in struct sockaddr_ieee802154 727 * (16 bits between 'family' and 'addr') and in struct 728 * ieee802154_addr_sa (16 bits at the end of the structure). 729 */ 730 memset(saddr, 0, sizeof(*saddr)); 731 732 saddr->family = AF_IEEE802154; 733 ieee802154_addr_to_sa(&saddr->addr, &mac_cb(skb)->source); 734 *addr_len = sizeof(*saddr); 735 } 736 737 if (ro->want_lqi) { 738 err = put_cmsg(msg, SOL_IEEE802154, WPAN_WANTLQI, 739 sizeof(uint8_t), &(mac_cb(skb)->lqi)); 740 if (err) 741 goto done; 742 } 743 744 if (flags & MSG_TRUNC) 745 copied = skb->len; 746 done: 747 skb_free_datagram(sk, skb); 748 out: 749 if (err) 750 return err; 751 return copied; 752 } 753 754 static int dgram_rcv_skb(struct sock *sk, struct sk_buff *skb) 755 { 756 skb = skb_share_check(skb, GFP_ATOMIC); 757 if (!skb) 758 return NET_RX_DROP; 759 760 if (sock_queue_rcv_skb(sk, skb) < 0) { 761 kfree_skb(skb); 762 return NET_RX_DROP; 763 } 764 765 return NET_RX_SUCCESS; 766 } 767 768 static inline bool 769 ieee802154_match_sock(__le64 hw_addr, __le16 pan_id, __le16 short_addr, 770 struct dgram_sock *ro) 771 { 772 if (!ro->bound) 773 return true; 774 775 if (ro->src_addr.mode == IEEE802154_ADDR_LONG && 776 hw_addr == ro->src_addr.extended_addr) 777 return true; 778 779 if (ro->src_addr.mode == IEEE802154_ADDR_SHORT && 780 pan_id == ro->src_addr.pan_id && 781 short_addr == ro->src_addr.short_addr) 782 return true; 783 784 return false; 785 } 786 787 static int ieee802154_dgram_deliver(struct net_device *dev, struct sk_buff *skb) 788 { 789 struct sock *sk, *prev = NULL; 790 int ret = NET_RX_SUCCESS; 791 __le16 pan_id, short_addr; 792 __le64 hw_addr; 793 794 /* Data frame processing */ 795 BUG_ON(dev->type != ARPHRD_IEEE802154); 796 797 pan_id = dev->ieee802154_ptr->pan_id; 798 short_addr = dev->ieee802154_ptr->short_addr; 799 hw_addr = dev->ieee802154_ptr->extended_addr; 800 801 read_lock(&dgram_lock); 802 sk_for_each(sk, &dgram_head) { 803 if (ieee802154_match_sock(hw_addr, pan_id, short_addr, 804 dgram_sk(sk))) { 805 if (prev) { 806 struct sk_buff *clone; 807 808 clone = skb_clone(skb, GFP_ATOMIC); 809 if (clone) 810 dgram_rcv_skb(prev, clone); 811 } 812 813 prev = sk; 814 } 815 } 816 817 if (prev) { 818 dgram_rcv_skb(prev, skb); 819 } else { 820 kfree_skb(skb); 821 ret = NET_RX_DROP; 822 } 823 read_unlock(&dgram_lock); 824 825 return ret; 826 } 827 828 static int dgram_getsockopt(struct sock *sk, int level, int optname, 829 char __user *optval, int __user *optlen) 830 { 831 struct dgram_sock *ro = dgram_sk(sk); 832 833 int val, len; 834 835 if (level != SOL_IEEE802154) 836 return -EOPNOTSUPP; 837 838 if (get_user(len, optlen)) 839 return -EFAULT; 840 841 len = min_t(unsigned int, len, sizeof(int)); 842 843 switch (optname) { 844 case WPAN_WANTACK: 845 val = ro->want_ack; 846 break; 847 case WPAN_WANTLQI: 848 val = ro->want_lqi; 849 break; 850 case WPAN_SECURITY: 851 if (!ro->secen_override) 852 val = WPAN_SECURITY_DEFAULT; 853 else if (ro->secen) 854 val = WPAN_SECURITY_ON; 855 else 856 val = WPAN_SECURITY_OFF; 857 break; 858 case WPAN_SECURITY_LEVEL: 859 if (!ro->seclevel_override) 860 val = WPAN_SECURITY_LEVEL_DEFAULT; 861 else 862 val = ro->seclevel; 863 break; 864 default: 865 return -ENOPROTOOPT; 866 } 867 868 if (put_user(len, optlen)) 869 return -EFAULT; 870 if (copy_to_user(optval, &val, len)) 871 return -EFAULT; 872 return 0; 873 } 874 875 static int dgram_setsockopt(struct sock *sk, int level, int optname, 876 sockptr_t optval, unsigned int optlen) 877 { 878 struct dgram_sock *ro = dgram_sk(sk); 879 struct net *net = sock_net(sk); 880 int val; 881 int err = 0; 882 883 if (optlen < sizeof(int)) 884 return -EINVAL; 885 886 if (copy_from_sockptr(&val, optval, sizeof(int))) 887 return -EFAULT; 888 889 lock_sock(sk); 890 891 switch (optname) { 892 case WPAN_WANTACK: 893 ro->want_ack = !!val; 894 break; 895 case WPAN_WANTLQI: 896 ro->want_lqi = !!val; 897 break; 898 case WPAN_SECURITY: 899 if (!ns_capable(net->user_ns, CAP_NET_ADMIN) && 900 !ns_capable(net->user_ns, CAP_NET_RAW)) { 901 err = -EPERM; 902 break; 903 } 904 905 switch (val) { 906 case WPAN_SECURITY_DEFAULT: 907 ro->secen_override = 0; 908 break; 909 case WPAN_SECURITY_ON: 910 ro->secen_override = 1; 911 ro->secen = 1; 912 break; 913 case WPAN_SECURITY_OFF: 914 ro->secen_override = 1; 915 ro->secen = 0; 916 break; 917 default: 918 err = -EINVAL; 919 break; 920 } 921 break; 922 case WPAN_SECURITY_LEVEL: 923 if (!ns_capable(net->user_ns, CAP_NET_ADMIN) && 924 !ns_capable(net->user_ns, CAP_NET_RAW)) { 925 err = -EPERM; 926 break; 927 } 928 929 if (val < WPAN_SECURITY_LEVEL_DEFAULT || 930 val > IEEE802154_SCF_SECLEVEL_ENC_MIC128) { 931 err = -EINVAL; 932 } else if (val == WPAN_SECURITY_LEVEL_DEFAULT) { 933 ro->seclevel_override = 0; 934 } else { 935 ro->seclevel_override = 1; 936 ro->seclevel = val; 937 } 938 break; 939 default: 940 err = -ENOPROTOOPT; 941 break; 942 } 943 944 release_sock(sk); 945 return err; 946 } 947 948 static struct proto ieee802154_dgram_prot = { 949 .name = "IEEE-802.15.4-MAC", 950 .owner = THIS_MODULE, 951 .obj_size = sizeof(struct dgram_sock), 952 .init = dgram_init, 953 .close = dgram_close, 954 .bind = dgram_bind, 955 .sendmsg = dgram_sendmsg, 956 .recvmsg = dgram_recvmsg, 957 .hash = dgram_hash, 958 .unhash = dgram_unhash, 959 .connect = dgram_connect, 960 .disconnect = dgram_disconnect, 961 .ioctl = dgram_ioctl, 962 .getsockopt = dgram_getsockopt, 963 .setsockopt = dgram_setsockopt, 964 }; 965 966 static const struct proto_ops ieee802154_dgram_ops = { 967 .family = PF_IEEE802154, 968 .owner = THIS_MODULE, 969 .release = ieee802154_sock_release, 970 .bind = ieee802154_sock_bind, 971 .connect = ieee802154_sock_connect, 972 .socketpair = sock_no_socketpair, 973 .accept = sock_no_accept, 974 .getname = sock_no_getname, 975 .poll = datagram_poll, 976 .ioctl = ieee802154_sock_ioctl, 977 .gettstamp = sock_gettstamp, 978 .listen = sock_no_listen, 979 .shutdown = sock_no_shutdown, 980 .setsockopt = sock_common_setsockopt, 981 .getsockopt = sock_common_getsockopt, 982 .sendmsg = ieee802154_sock_sendmsg, 983 .recvmsg = sock_common_recvmsg, 984 .mmap = sock_no_mmap, 985 .sendpage = sock_no_sendpage, 986 }; 987 988 static void ieee802154_sock_destruct(struct sock *sk) 989 { 990 skb_queue_purge(&sk->sk_receive_queue); 991 } 992 993 /* Create a socket. Initialise the socket, blank the addresses 994 * set the state. 995 */ 996 static int ieee802154_create(struct net *net, struct socket *sock, 997 int protocol, int kern) 998 { 999 struct sock *sk; 1000 int rc; 1001 struct proto *proto; 1002 const struct proto_ops *ops; 1003 1004 if (!net_eq(net, &init_net)) 1005 return -EAFNOSUPPORT; 1006 1007 switch (sock->type) { 1008 case SOCK_RAW: 1009 rc = -EPERM; 1010 if (!capable(CAP_NET_RAW)) 1011 goto out; 1012 proto = &ieee802154_raw_prot; 1013 ops = &ieee802154_raw_ops; 1014 break; 1015 case SOCK_DGRAM: 1016 proto = &ieee802154_dgram_prot; 1017 ops = &ieee802154_dgram_ops; 1018 break; 1019 default: 1020 rc = -ESOCKTNOSUPPORT; 1021 goto out; 1022 } 1023 1024 rc = -ENOMEM; 1025 sk = sk_alloc(net, PF_IEEE802154, GFP_KERNEL, proto, kern); 1026 if (!sk) 1027 goto out; 1028 rc = 0; 1029 1030 sock->ops = ops; 1031 1032 sock_init_data(sock, sk); 1033 sk->sk_destruct = ieee802154_sock_destruct; 1034 sk->sk_family = PF_IEEE802154; 1035 1036 /* Checksums on by default */ 1037 sock_set_flag(sk, SOCK_ZAPPED); 1038 1039 if (sk->sk_prot->hash) { 1040 rc = sk->sk_prot->hash(sk); 1041 if (rc) { 1042 sk_common_release(sk); 1043 goto out; 1044 } 1045 } 1046 1047 if (sk->sk_prot->init) { 1048 rc = sk->sk_prot->init(sk); 1049 if (rc) 1050 sk_common_release(sk); 1051 } 1052 out: 1053 return rc; 1054 } 1055 1056 static const struct net_proto_family ieee802154_family_ops = { 1057 .family = PF_IEEE802154, 1058 .create = ieee802154_create, 1059 .owner = THIS_MODULE, 1060 }; 1061 1062 static int ieee802154_rcv(struct sk_buff *skb, struct net_device *dev, 1063 struct packet_type *pt, struct net_device *orig_dev) 1064 { 1065 if (!netif_running(dev)) 1066 goto drop; 1067 pr_debug("got frame, type %d, dev %p\n", dev->type, dev); 1068 #ifdef DEBUG 1069 print_hex_dump_bytes("ieee802154_rcv ", 1070 DUMP_PREFIX_NONE, skb->data, skb->len); 1071 #endif 1072 1073 if (!net_eq(dev_net(dev), &init_net)) 1074 goto drop; 1075 1076 ieee802154_raw_deliver(dev, skb); 1077 1078 if (dev->type != ARPHRD_IEEE802154) 1079 goto drop; 1080 1081 if (skb->pkt_type != PACKET_OTHERHOST) 1082 return ieee802154_dgram_deliver(dev, skb); 1083 1084 drop: 1085 kfree_skb(skb); 1086 return NET_RX_DROP; 1087 } 1088 1089 static struct packet_type ieee802154_packet_type = { 1090 .type = htons(ETH_P_IEEE802154), 1091 .func = ieee802154_rcv, 1092 }; 1093 1094 static int __init af_ieee802154_init(void) 1095 { 1096 int rc; 1097 1098 rc = proto_register(&ieee802154_raw_prot, 1); 1099 if (rc) 1100 goto out; 1101 1102 rc = proto_register(&ieee802154_dgram_prot, 1); 1103 if (rc) 1104 goto err_dgram; 1105 1106 /* Tell SOCKET that we are alive */ 1107 rc = sock_register(&ieee802154_family_ops); 1108 if (rc) 1109 goto err_sock; 1110 dev_add_pack(&ieee802154_packet_type); 1111 1112 rc = 0; 1113 goto out; 1114 1115 err_sock: 1116 proto_unregister(&ieee802154_dgram_prot); 1117 err_dgram: 1118 proto_unregister(&ieee802154_raw_prot); 1119 out: 1120 return rc; 1121 } 1122 1123 static void __exit af_ieee802154_remove(void) 1124 { 1125 dev_remove_pack(&ieee802154_packet_type); 1126 sock_unregister(PF_IEEE802154); 1127 proto_unregister(&ieee802154_dgram_prot); 1128 proto_unregister(&ieee802154_raw_prot); 1129 } 1130 1131 module_init(af_ieee802154_init); 1132 module_exit(af_ieee802154_remove); 1133 1134 MODULE_LICENSE("GPL"); 1135 MODULE_ALIAS_NETPROTO(PF_IEEE802154); 1136