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 = IEEE802154_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 = IEEE802154_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 = wpan_dev_hard_header(skb, dev, &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 /* Clear the implicit padding in struct sockaddr_ieee802154 735 * (16 bits between 'family' and 'addr') and in struct 736 * ieee802154_addr_sa (16 bits at the end of the structure). 737 */ 738 memset(saddr, 0, sizeof(*saddr)); 739 740 saddr->family = AF_IEEE802154; 741 ieee802154_addr_to_sa(&saddr->addr, &mac_cb(skb)->source); 742 *addr_len = sizeof(*saddr); 743 } 744 745 if (flags & MSG_TRUNC) 746 copied = skb->len; 747 done: 748 skb_free_datagram(sk, skb); 749 out: 750 if (err) 751 return err; 752 return copied; 753 } 754 755 static int dgram_rcv_skb(struct sock *sk, struct sk_buff *skb) 756 { 757 skb = skb_share_check(skb, GFP_ATOMIC); 758 if (!skb) 759 return NET_RX_DROP; 760 761 if (sock_queue_rcv_skb(sk, skb) < 0) { 762 kfree_skb(skb); 763 return NET_RX_DROP; 764 } 765 766 return NET_RX_SUCCESS; 767 } 768 769 static inline bool 770 ieee802154_match_sock(__le64 hw_addr, __le16 pan_id, __le16 short_addr, 771 struct dgram_sock *ro) 772 { 773 if (!ro->bound) 774 return true; 775 776 if (ro->src_addr.mode == IEEE802154_ADDR_LONG && 777 hw_addr == ro->src_addr.extended_addr) 778 return true; 779 780 if (ro->src_addr.mode == IEEE802154_ADDR_SHORT && 781 pan_id == ro->src_addr.pan_id && 782 short_addr == ro->src_addr.short_addr) 783 return true; 784 785 return false; 786 } 787 788 static int ieee802154_dgram_deliver(struct net_device *dev, struct sk_buff *skb) 789 { 790 struct sock *sk, *prev = NULL; 791 int ret = NET_RX_SUCCESS; 792 __le16 pan_id, short_addr; 793 __le64 hw_addr; 794 795 /* Data frame processing */ 796 BUG_ON(dev->type != ARPHRD_IEEE802154); 797 798 pan_id = dev->ieee802154_ptr->pan_id; 799 short_addr = dev->ieee802154_ptr->short_addr; 800 hw_addr = dev->ieee802154_ptr->extended_addr; 801 802 read_lock(&dgram_lock); 803 sk_for_each(sk, &dgram_head) { 804 if (ieee802154_match_sock(hw_addr, pan_id, short_addr, 805 dgram_sk(sk))) { 806 if (prev) { 807 struct sk_buff *clone; 808 809 clone = skb_clone(skb, GFP_ATOMIC); 810 if (clone) 811 dgram_rcv_skb(prev, clone); 812 } 813 814 prev = sk; 815 } 816 } 817 818 if (prev) { 819 dgram_rcv_skb(prev, skb); 820 } else { 821 kfree_skb(skb); 822 ret = NET_RX_DROP; 823 } 824 read_unlock(&dgram_lock); 825 826 return ret; 827 } 828 829 static int dgram_getsockopt(struct sock *sk, int level, int optname, 830 char __user *optval, int __user *optlen) 831 { 832 struct dgram_sock *ro = dgram_sk(sk); 833 834 int val, len; 835 836 if (level != SOL_IEEE802154) 837 return -EOPNOTSUPP; 838 839 if (get_user(len, optlen)) 840 return -EFAULT; 841 842 len = min_t(unsigned int, len, sizeof(int)); 843 844 switch (optname) { 845 case WPAN_WANTACK: 846 val = ro->want_ack; 847 break; 848 case WPAN_SECURITY: 849 if (!ro->secen_override) 850 val = WPAN_SECURITY_DEFAULT; 851 else if (ro->secen) 852 val = WPAN_SECURITY_ON; 853 else 854 val = WPAN_SECURITY_OFF; 855 break; 856 case WPAN_SECURITY_LEVEL: 857 if (!ro->seclevel_override) 858 val = WPAN_SECURITY_LEVEL_DEFAULT; 859 else 860 val = ro->seclevel; 861 break; 862 default: 863 return -ENOPROTOOPT; 864 } 865 866 if (put_user(len, optlen)) 867 return -EFAULT; 868 if (copy_to_user(optval, &val, len)) 869 return -EFAULT; 870 return 0; 871 } 872 873 static int dgram_setsockopt(struct sock *sk, int level, int optname, 874 char __user *optval, unsigned int optlen) 875 { 876 struct dgram_sock *ro = dgram_sk(sk); 877 struct net *net = sock_net(sk); 878 int val; 879 int err = 0; 880 881 if (optlen < sizeof(int)) 882 return -EINVAL; 883 884 if (get_user(val, (int __user *)optval)) 885 return -EFAULT; 886 887 lock_sock(sk); 888 889 switch (optname) { 890 case WPAN_WANTACK: 891 ro->want_ack = !!val; 892 break; 893 case WPAN_SECURITY: 894 if (!ns_capable(net->user_ns, CAP_NET_ADMIN) && 895 !ns_capable(net->user_ns, CAP_NET_RAW)) { 896 err = -EPERM; 897 break; 898 } 899 900 switch (val) { 901 case WPAN_SECURITY_DEFAULT: 902 ro->secen_override = 0; 903 break; 904 case WPAN_SECURITY_ON: 905 ro->secen_override = 1; 906 ro->secen = 1; 907 break; 908 case WPAN_SECURITY_OFF: 909 ro->secen_override = 1; 910 ro->secen = 0; 911 break; 912 default: 913 err = -EINVAL; 914 break; 915 } 916 break; 917 case WPAN_SECURITY_LEVEL: 918 if (!ns_capable(net->user_ns, CAP_NET_ADMIN) && 919 !ns_capable(net->user_ns, CAP_NET_RAW)) { 920 err = -EPERM; 921 break; 922 } 923 924 if (val < WPAN_SECURITY_LEVEL_DEFAULT || 925 val > IEEE802154_SCF_SECLEVEL_ENC_MIC128) { 926 err = -EINVAL; 927 } else if (val == WPAN_SECURITY_LEVEL_DEFAULT) { 928 ro->seclevel_override = 0; 929 } else { 930 ro->seclevel_override = 1; 931 ro->seclevel = val; 932 } 933 break; 934 default: 935 err = -ENOPROTOOPT; 936 break; 937 } 938 939 release_sock(sk); 940 return err; 941 } 942 943 static struct proto ieee802154_dgram_prot = { 944 .name = "IEEE-802.15.4-MAC", 945 .owner = THIS_MODULE, 946 .obj_size = sizeof(struct dgram_sock), 947 .init = dgram_init, 948 .close = dgram_close, 949 .bind = dgram_bind, 950 .sendmsg = dgram_sendmsg, 951 .recvmsg = dgram_recvmsg, 952 .hash = dgram_hash, 953 .unhash = dgram_unhash, 954 .connect = dgram_connect, 955 .disconnect = dgram_disconnect, 956 .ioctl = dgram_ioctl, 957 .getsockopt = dgram_getsockopt, 958 .setsockopt = dgram_setsockopt, 959 }; 960 961 static const struct proto_ops ieee802154_dgram_ops = { 962 .family = PF_IEEE802154, 963 .owner = THIS_MODULE, 964 .release = ieee802154_sock_release, 965 .bind = ieee802154_sock_bind, 966 .connect = ieee802154_sock_connect, 967 .socketpair = sock_no_socketpair, 968 .accept = sock_no_accept, 969 .getname = sock_no_getname, 970 .poll = datagram_poll, 971 .ioctl = ieee802154_sock_ioctl, 972 .listen = sock_no_listen, 973 .shutdown = sock_no_shutdown, 974 .setsockopt = sock_common_setsockopt, 975 .getsockopt = sock_common_getsockopt, 976 .sendmsg = ieee802154_sock_sendmsg, 977 .recvmsg = sock_common_recvmsg, 978 .mmap = sock_no_mmap, 979 .sendpage = sock_no_sendpage, 980 #ifdef CONFIG_COMPAT 981 .compat_setsockopt = compat_sock_common_setsockopt, 982 .compat_getsockopt = compat_sock_common_getsockopt, 983 #endif 984 }; 985 986 /* Create a socket. Initialise the socket, blank the addresses 987 * set the state. 988 */ 989 static int ieee802154_create(struct net *net, struct socket *sock, 990 int protocol, int kern) 991 { 992 struct sock *sk; 993 int rc; 994 struct proto *proto; 995 const struct proto_ops *ops; 996 997 if (!net_eq(net, &init_net)) 998 return -EAFNOSUPPORT; 999 1000 switch (sock->type) { 1001 case SOCK_RAW: 1002 proto = &ieee802154_raw_prot; 1003 ops = &ieee802154_raw_ops; 1004 break; 1005 case SOCK_DGRAM: 1006 proto = &ieee802154_dgram_prot; 1007 ops = &ieee802154_dgram_ops; 1008 break; 1009 default: 1010 rc = -ESOCKTNOSUPPORT; 1011 goto out; 1012 } 1013 1014 rc = -ENOMEM; 1015 sk = sk_alloc(net, PF_IEEE802154, GFP_KERNEL, proto, kern); 1016 if (!sk) 1017 goto out; 1018 rc = 0; 1019 1020 sock->ops = ops; 1021 1022 sock_init_data(sock, sk); 1023 /* FIXME: sk->sk_destruct */ 1024 sk->sk_family = PF_IEEE802154; 1025 1026 /* Checksums on by default */ 1027 sock_set_flag(sk, SOCK_ZAPPED); 1028 1029 if (sk->sk_prot->hash) 1030 sk->sk_prot->hash(sk); 1031 1032 if (sk->sk_prot->init) { 1033 rc = sk->sk_prot->init(sk); 1034 if (rc) 1035 sk_common_release(sk); 1036 } 1037 out: 1038 return rc; 1039 } 1040 1041 static const struct net_proto_family ieee802154_family_ops = { 1042 .family = PF_IEEE802154, 1043 .create = ieee802154_create, 1044 .owner = THIS_MODULE, 1045 }; 1046 1047 static int ieee802154_rcv(struct sk_buff *skb, struct net_device *dev, 1048 struct packet_type *pt, struct net_device *orig_dev) 1049 { 1050 if (!netif_running(dev)) 1051 goto drop; 1052 pr_debug("got frame, type %d, dev %p\n", dev->type, dev); 1053 #ifdef DEBUG 1054 print_hex_dump_bytes("ieee802154_rcv ", 1055 DUMP_PREFIX_NONE, skb->data, skb->len); 1056 #endif 1057 1058 if (!net_eq(dev_net(dev), &init_net)) 1059 goto drop; 1060 1061 ieee802154_raw_deliver(dev, skb); 1062 1063 if (dev->type != ARPHRD_IEEE802154) 1064 goto drop; 1065 1066 if (skb->pkt_type != PACKET_OTHERHOST) 1067 return ieee802154_dgram_deliver(dev, skb); 1068 1069 drop: 1070 kfree_skb(skb); 1071 return NET_RX_DROP; 1072 } 1073 1074 static struct packet_type ieee802154_packet_type = { 1075 .type = htons(ETH_P_IEEE802154), 1076 .func = ieee802154_rcv, 1077 }; 1078 1079 static int __init af_ieee802154_init(void) 1080 { 1081 int rc = -EINVAL; 1082 1083 rc = proto_register(&ieee802154_raw_prot, 1); 1084 if (rc) 1085 goto out; 1086 1087 rc = proto_register(&ieee802154_dgram_prot, 1); 1088 if (rc) 1089 goto err_dgram; 1090 1091 /* Tell SOCKET that we are alive */ 1092 rc = sock_register(&ieee802154_family_ops); 1093 if (rc) 1094 goto err_sock; 1095 dev_add_pack(&ieee802154_packet_type); 1096 1097 rc = 0; 1098 goto out; 1099 1100 err_sock: 1101 proto_unregister(&ieee802154_dgram_prot); 1102 err_dgram: 1103 proto_unregister(&ieee802154_raw_prot); 1104 out: 1105 return rc; 1106 } 1107 1108 static void __exit af_ieee802154_remove(void) 1109 { 1110 dev_remove_pack(&ieee802154_packet_type); 1111 sock_unregister(PF_IEEE802154); 1112 proto_unregister(&ieee802154_dgram_prot); 1113 proto_unregister(&ieee802154_raw_prot); 1114 } 1115 1116 module_init(af_ieee802154_init); 1117 module_exit(af_ieee802154_remove); 1118 1119 MODULE_LICENSE("GPL"); 1120 MODULE_ALIAS_NETPROTO(PF_IEEE802154); 1121