Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * IEEE802154.4 socket interface
0004  *
0005  * Copyright 2007, 2008 Siemens AG
0006  *
0007  * Written by:
0008  * Sergey Lapin <slapin@ossfans.org>
0009  * Maxim Gorbachyov <maxim.gorbachev@siemens.com>
0010  */
0011 
0012 #include <linux/net.h>
0013 #include <linux/capability.h>
0014 #include <linux/module.h>
0015 #include <linux/if_arp.h>
0016 #include <linux/if.h>
0017 #include <linux/termios.h>  /* For TIOCOUTQ/INQ */
0018 #include <linux/list.h>
0019 #include <linux/slab.h>
0020 #include <linux/socket.h>
0021 #include <net/datalink.h>
0022 #include <net/psnap.h>
0023 #include <net/sock.h>
0024 #include <net/tcp_states.h>
0025 #include <net/route.h>
0026 
0027 #include <net/af_ieee802154.h>
0028 #include <net/ieee802154_netdev.h>
0029 
0030 /* Utility function for families */
0031 static struct net_device*
0032 ieee802154_get_dev(struct net *net, const struct ieee802154_addr *addr)
0033 {
0034     struct net_device *dev = NULL;
0035     struct net_device *tmp;
0036     __le16 pan_id, short_addr;
0037     u8 hwaddr[IEEE802154_ADDR_LEN];
0038 
0039     switch (addr->mode) {
0040     case IEEE802154_ADDR_LONG:
0041         ieee802154_devaddr_to_raw(hwaddr, addr->extended_addr);
0042         rcu_read_lock();
0043         dev = dev_getbyhwaddr_rcu(net, ARPHRD_IEEE802154, hwaddr);
0044         dev_hold(dev);
0045         rcu_read_unlock();
0046         break;
0047     case IEEE802154_ADDR_SHORT:
0048         if (addr->pan_id == cpu_to_le16(IEEE802154_PANID_BROADCAST) ||
0049             addr->short_addr == cpu_to_le16(IEEE802154_ADDR_UNDEF) ||
0050             addr->short_addr == cpu_to_le16(IEEE802154_ADDR_BROADCAST))
0051             break;
0052 
0053         rtnl_lock();
0054 
0055         for_each_netdev(net, tmp) {
0056             if (tmp->type != ARPHRD_IEEE802154)
0057                 continue;
0058 
0059             pan_id = tmp->ieee802154_ptr->pan_id;
0060             short_addr = tmp->ieee802154_ptr->short_addr;
0061             if (pan_id == addr->pan_id &&
0062                 short_addr == addr->short_addr) {
0063                 dev = tmp;
0064                 dev_hold(dev);
0065                 break;
0066             }
0067         }
0068 
0069         rtnl_unlock();
0070         break;
0071     default:
0072         pr_warn("Unsupported ieee802154 address type: %d\n",
0073             addr->mode);
0074         break;
0075     }
0076 
0077     return dev;
0078 }
0079 
0080 static int ieee802154_sock_release(struct socket *sock)
0081 {
0082     struct sock *sk = sock->sk;
0083 
0084     if (sk) {
0085         sock->sk = NULL;
0086         sk->sk_prot->close(sk, 0);
0087     }
0088     return 0;
0089 }
0090 
0091 static int ieee802154_sock_sendmsg(struct socket *sock, struct msghdr *msg,
0092                    size_t len)
0093 {
0094     struct sock *sk = sock->sk;
0095 
0096     return sk->sk_prot->sendmsg(sk, msg, len);
0097 }
0098 
0099 static int ieee802154_sock_bind(struct socket *sock, struct sockaddr *uaddr,
0100                 int addr_len)
0101 {
0102     struct sock *sk = sock->sk;
0103 
0104     if (sk->sk_prot->bind)
0105         return sk->sk_prot->bind(sk, uaddr, addr_len);
0106 
0107     return sock_no_bind(sock, uaddr, addr_len);
0108 }
0109 
0110 static int ieee802154_sock_connect(struct socket *sock, struct sockaddr *uaddr,
0111                    int addr_len, int flags)
0112 {
0113     struct sock *sk = sock->sk;
0114 
0115     if (addr_len < sizeof(uaddr->sa_family))
0116         return -EINVAL;
0117 
0118     if (uaddr->sa_family == AF_UNSPEC)
0119         return sk->sk_prot->disconnect(sk, flags);
0120 
0121     return sk->sk_prot->connect(sk, uaddr, addr_len);
0122 }
0123 
0124 static int ieee802154_dev_ioctl(struct sock *sk, struct ifreq __user *arg,
0125                 unsigned int cmd)
0126 {
0127     struct ifreq ifr;
0128     int ret = -ENOIOCTLCMD;
0129     struct net_device *dev;
0130 
0131     if (get_user_ifreq(&ifr, NULL, arg))
0132         return -EFAULT;
0133 
0134     ifr.ifr_name[IFNAMSIZ-1] = 0;
0135 
0136     dev_load(sock_net(sk), ifr.ifr_name);
0137     dev = dev_get_by_name(sock_net(sk), ifr.ifr_name);
0138 
0139     if (!dev)
0140         return -ENODEV;
0141 
0142     if (dev->type == ARPHRD_IEEE802154 && dev->netdev_ops->ndo_do_ioctl)
0143         ret = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, cmd);
0144 
0145     if (!ret && put_user_ifreq(&ifr, arg))
0146         ret = -EFAULT;
0147     dev_put(dev);
0148 
0149     return ret;
0150 }
0151 
0152 static int ieee802154_sock_ioctl(struct socket *sock, unsigned int cmd,
0153                  unsigned long arg)
0154 {
0155     struct sock *sk = sock->sk;
0156 
0157     switch (cmd) {
0158     case SIOCGIFADDR:
0159     case SIOCSIFADDR:
0160         return ieee802154_dev_ioctl(sk, (struct ifreq __user *)arg,
0161                 cmd);
0162     default:
0163         if (!sk->sk_prot->ioctl)
0164             return -ENOIOCTLCMD;
0165         return sk->sk_prot->ioctl(sk, cmd, arg);
0166     }
0167 }
0168 
0169 /* RAW Sockets (802.15.4 created in userspace) */
0170 static HLIST_HEAD(raw_head);
0171 static DEFINE_RWLOCK(raw_lock);
0172 
0173 static int raw_hash(struct sock *sk)
0174 {
0175     write_lock_bh(&raw_lock);
0176     sk_add_node(sk, &raw_head);
0177     write_unlock_bh(&raw_lock);
0178     sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
0179 
0180     return 0;
0181 }
0182 
0183 static void raw_unhash(struct sock *sk)
0184 {
0185     write_lock_bh(&raw_lock);
0186     if (sk_del_node_init(sk))
0187         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
0188     write_unlock_bh(&raw_lock);
0189 }
0190 
0191 static void raw_close(struct sock *sk, long timeout)
0192 {
0193     sk_common_release(sk);
0194 }
0195 
0196 static int raw_bind(struct sock *sk, struct sockaddr *_uaddr, int len)
0197 {
0198     struct ieee802154_addr addr;
0199     struct sockaddr_ieee802154 *uaddr = (struct sockaddr_ieee802154 *)_uaddr;
0200     int err = 0;
0201     struct net_device *dev = NULL;
0202 
0203     err = ieee802154_sockaddr_check_size(uaddr, len);
0204     if (err < 0)
0205         return err;
0206 
0207     uaddr = (struct sockaddr_ieee802154 *)_uaddr;
0208     if (uaddr->family != AF_IEEE802154)
0209         return -EINVAL;
0210 
0211     lock_sock(sk);
0212 
0213     ieee802154_addr_from_sa(&addr, &uaddr->addr);
0214     dev = ieee802154_get_dev(sock_net(sk), &addr);
0215     if (!dev) {
0216         err = -ENODEV;
0217         goto out;
0218     }
0219 
0220     sk->sk_bound_dev_if = dev->ifindex;
0221     sk_dst_reset(sk);
0222 
0223     dev_put(dev);
0224 out:
0225     release_sock(sk);
0226 
0227     return err;
0228 }
0229 
0230 static int raw_connect(struct sock *sk, struct sockaddr *uaddr,
0231                int addr_len)
0232 {
0233     return -ENOTSUPP;
0234 }
0235 
0236 static int raw_disconnect(struct sock *sk, int flags)
0237 {
0238     return 0;
0239 }
0240 
0241 static int raw_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
0242 {
0243     struct net_device *dev;
0244     unsigned int mtu;
0245     struct sk_buff *skb;
0246     int hlen, tlen;
0247     int err;
0248 
0249     if (msg->msg_flags & MSG_OOB) {
0250         pr_debug("msg->msg_flags = 0x%x\n", msg->msg_flags);
0251         return -EOPNOTSUPP;
0252     }
0253 
0254     lock_sock(sk);
0255     if (!sk->sk_bound_dev_if)
0256         dev = dev_getfirstbyhwtype(sock_net(sk), ARPHRD_IEEE802154);
0257     else
0258         dev = dev_get_by_index(sock_net(sk), sk->sk_bound_dev_if);
0259     release_sock(sk);
0260 
0261     if (!dev) {
0262         pr_debug("no dev\n");
0263         err = -ENXIO;
0264         goto out;
0265     }
0266 
0267     mtu = IEEE802154_MTU;
0268     pr_debug("name = %s, mtu = %u\n", dev->name, mtu);
0269 
0270     if (size > mtu) {
0271         pr_debug("size = %zu, mtu = %u\n", size, mtu);
0272         err = -EMSGSIZE;
0273         goto out_dev;
0274     }
0275 
0276     hlen = LL_RESERVED_SPACE(dev);
0277     tlen = dev->needed_tailroom;
0278     skb = sock_alloc_send_skb(sk, hlen + tlen + size,
0279                   msg->msg_flags & MSG_DONTWAIT, &err);
0280     if (!skb)
0281         goto out_dev;
0282 
0283     skb_reserve(skb, hlen);
0284 
0285     skb_reset_mac_header(skb);
0286     skb_reset_network_header(skb);
0287 
0288     err = memcpy_from_msg(skb_put(skb, size), msg, size);
0289     if (err < 0)
0290         goto out_skb;
0291 
0292     skb->dev = dev;
0293     skb->protocol = htons(ETH_P_IEEE802154);
0294 
0295     err = dev_queue_xmit(skb);
0296     if (err > 0)
0297         err = net_xmit_errno(err);
0298 
0299     dev_put(dev);
0300 
0301     return err ?: size;
0302 
0303 out_skb:
0304     kfree_skb(skb);
0305 out_dev:
0306     dev_put(dev);
0307 out:
0308     return err;
0309 }
0310 
0311 static int raw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
0312                int flags, int *addr_len)
0313 {
0314     size_t copied = 0;
0315     int err = -EOPNOTSUPP;
0316     struct sk_buff *skb;
0317 
0318     skb = skb_recv_datagram(sk, flags, &err);
0319     if (!skb)
0320         goto out;
0321 
0322     copied = skb->len;
0323     if (len < copied) {
0324         msg->msg_flags |= MSG_TRUNC;
0325         copied = len;
0326     }
0327 
0328     err = skb_copy_datagram_msg(skb, 0, msg, copied);
0329     if (err)
0330         goto done;
0331 
0332     sock_recv_cmsgs(msg, sk, skb);
0333 
0334     if (flags & MSG_TRUNC)
0335         copied = skb->len;
0336 done:
0337     skb_free_datagram(sk, skb);
0338 out:
0339     if (err)
0340         return err;
0341     return copied;
0342 }
0343 
0344 static int raw_rcv_skb(struct sock *sk, struct sk_buff *skb)
0345 {
0346     skb = skb_share_check(skb, GFP_ATOMIC);
0347     if (!skb)
0348         return NET_RX_DROP;
0349 
0350     if (sock_queue_rcv_skb(sk, skb) < 0) {
0351         kfree_skb(skb);
0352         return NET_RX_DROP;
0353     }
0354 
0355     return NET_RX_SUCCESS;
0356 }
0357 
0358 static void ieee802154_raw_deliver(struct net_device *dev, struct sk_buff *skb)
0359 {
0360     struct sock *sk;
0361 
0362     read_lock(&raw_lock);
0363     sk_for_each(sk, &raw_head) {
0364         bh_lock_sock(sk);
0365         if (!sk->sk_bound_dev_if ||
0366             sk->sk_bound_dev_if == dev->ifindex) {
0367             struct sk_buff *clone;
0368 
0369             clone = skb_clone(skb, GFP_ATOMIC);
0370             if (clone)
0371                 raw_rcv_skb(sk, clone);
0372         }
0373         bh_unlock_sock(sk);
0374     }
0375     read_unlock(&raw_lock);
0376 }
0377 
0378 static int raw_getsockopt(struct sock *sk, int level, int optname,
0379               char __user *optval, int __user *optlen)
0380 {
0381     return -EOPNOTSUPP;
0382 }
0383 
0384 static int raw_setsockopt(struct sock *sk, int level, int optname,
0385               sockptr_t optval, unsigned int optlen)
0386 {
0387     return -EOPNOTSUPP;
0388 }
0389 
0390 static struct proto ieee802154_raw_prot = {
0391     .name       = "IEEE-802.15.4-RAW",
0392     .owner      = THIS_MODULE,
0393     .obj_size   = sizeof(struct sock),
0394     .close      = raw_close,
0395     .bind       = raw_bind,
0396     .sendmsg    = raw_sendmsg,
0397     .recvmsg    = raw_recvmsg,
0398     .hash       = raw_hash,
0399     .unhash     = raw_unhash,
0400     .connect    = raw_connect,
0401     .disconnect = raw_disconnect,
0402     .getsockopt = raw_getsockopt,
0403     .setsockopt = raw_setsockopt,
0404 };
0405 
0406 static const struct proto_ops ieee802154_raw_ops = {
0407     .family        = PF_IEEE802154,
0408     .owner         = THIS_MODULE,
0409     .release       = ieee802154_sock_release,
0410     .bind          = ieee802154_sock_bind,
0411     .connect       = ieee802154_sock_connect,
0412     .socketpair    = sock_no_socketpair,
0413     .accept        = sock_no_accept,
0414     .getname       = sock_no_getname,
0415     .poll          = datagram_poll,
0416     .ioctl         = ieee802154_sock_ioctl,
0417     .gettstamp     = sock_gettstamp,
0418     .listen        = sock_no_listen,
0419     .shutdown      = sock_no_shutdown,
0420     .setsockopt    = sock_common_setsockopt,
0421     .getsockopt    = sock_common_getsockopt,
0422     .sendmsg       = ieee802154_sock_sendmsg,
0423     .recvmsg       = sock_common_recvmsg,
0424     .mmap          = sock_no_mmap,
0425     .sendpage      = sock_no_sendpage,
0426 };
0427 
0428 /* DGRAM Sockets (802.15.4 dataframes) */
0429 static HLIST_HEAD(dgram_head);
0430 static DEFINE_RWLOCK(dgram_lock);
0431 
0432 struct dgram_sock {
0433     struct sock sk;
0434 
0435     struct ieee802154_addr src_addr;
0436     struct ieee802154_addr dst_addr;
0437 
0438     unsigned int bound:1;
0439     unsigned int connected:1;
0440     unsigned int want_ack:1;
0441     unsigned int want_lqi:1;
0442     unsigned int secen:1;
0443     unsigned int secen_override:1;
0444     unsigned int seclevel:3;
0445     unsigned int seclevel_override:1;
0446 };
0447 
0448 static inline struct dgram_sock *dgram_sk(const struct sock *sk)
0449 {
0450     return container_of(sk, struct dgram_sock, sk);
0451 }
0452 
0453 static int dgram_hash(struct sock *sk)
0454 {
0455     write_lock_bh(&dgram_lock);
0456     sk_add_node(sk, &dgram_head);
0457     write_unlock_bh(&dgram_lock);
0458     sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
0459 
0460     return 0;
0461 }
0462 
0463 static void dgram_unhash(struct sock *sk)
0464 {
0465     write_lock_bh(&dgram_lock);
0466     if (sk_del_node_init(sk))
0467         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
0468     write_unlock_bh(&dgram_lock);
0469 }
0470 
0471 static int dgram_init(struct sock *sk)
0472 {
0473     struct dgram_sock *ro = dgram_sk(sk);
0474 
0475     ro->want_ack = 1;
0476     ro->want_lqi = 0;
0477     return 0;
0478 }
0479 
0480 static void dgram_close(struct sock *sk, long timeout)
0481 {
0482     sk_common_release(sk);
0483 }
0484 
0485 static int dgram_bind(struct sock *sk, struct sockaddr *uaddr, int len)
0486 {
0487     struct sockaddr_ieee802154 *addr = (struct sockaddr_ieee802154 *)uaddr;
0488     struct ieee802154_addr haddr;
0489     struct dgram_sock *ro = dgram_sk(sk);
0490     int err = -EINVAL;
0491     struct net_device *dev;
0492 
0493     lock_sock(sk);
0494 
0495     ro->bound = 0;
0496 
0497     err = ieee802154_sockaddr_check_size(addr, len);
0498     if (err < 0)
0499         goto out;
0500 
0501     if (addr->family != AF_IEEE802154)
0502         goto out;
0503 
0504     ieee802154_addr_from_sa(&haddr, &addr->addr);
0505     dev = ieee802154_get_dev(sock_net(sk), &haddr);
0506     if (!dev) {
0507         err = -ENODEV;
0508         goto out;
0509     }
0510 
0511     if (dev->type != ARPHRD_IEEE802154) {
0512         err = -ENODEV;
0513         goto out_put;
0514     }
0515 
0516     ro->src_addr = haddr;
0517 
0518     ro->bound = 1;
0519     err = 0;
0520 out_put:
0521     dev_put(dev);
0522 out:
0523     release_sock(sk);
0524 
0525     return err;
0526 }
0527 
0528 static int dgram_ioctl(struct sock *sk, int cmd, unsigned long arg)
0529 {
0530     switch (cmd) {
0531     case SIOCOUTQ:
0532     {
0533         int amount = sk_wmem_alloc_get(sk);
0534 
0535         return put_user(amount, (int __user *)arg);
0536     }
0537 
0538     case SIOCINQ:
0539     {
0540         struct sk_buff *skb;
0541         unsigned long amount;
0542 
0543         amount = 0;
0544         spin_lock_bh(&sk->sk_receive_queue.lock);
0545         skb = skb_peek(&sk->sk_receive_queue);
0546         if (skb) {
0547             /* We will only return the amount
0548              * of this packet since that is all
0549              * that will be read.
0550              */
0551             amount = skb->len - ieee802154_hdr_length(skb);
0552         }
0553         spin_unlock_bh(&sk->sk_receive_queue.lock);
0554         return put_user(amount, (int __user *)arg);
0555     }
0556     }
0557 
0558     return -ENOIOCTLCMD;
0559 }
0560 
0561 /* FIXME: autobind */
0562 static int dgram_connect(struct sock *sk, struct sockaddr *uaddr,
0563              int len)
0564 {
0565     struct sockaddr_ieee802154 *addr = (struct sockaddr_ieee802154 *)uaddr;
0566     struct dgram_sock *ro = dgram_sk(sk);
0567     int err = 0;
0568 
0569     err = ieee802154_sockaddr_check_size(addr, len);
0570     if (err < 0)
0571         return err;
0572 
0573     if (addr->family != AF_IEEE802154)
0574         return -EINVAL;
0575 
0576     lock_sock(sk);
0577 
0578     if (!ro->bound) {
0579         err = -ENETUNREACH;
0580         goto out;
0581     }
0582 
0583     ieee802154_addr_from_sa(&ro->dst_addr, &addr->addr);
0584     ro->connected = 1;
0585 
0586 out:
0587     release_sock(sk);
0588     return err;
0589 }
0590 
0591 static int dgram_disconnect(struct sock *sk, int flags)
0592 {
0593     struct dgram_sock *ro = dgram_sk(sk);
0594 
0595     lock_sock(sk);
0596     ro->connected = 0;
0597     release_sock(sk);
0598 
0599     return 0;
0600 }
0601 
0602 static int dgram_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
0603 {
0604     struct net_device *dev;
0605     unsigned int mtu;
0606     struct sk_buff *skb;
0607     struct ieee802154_mac_cb *cb;
0608     struct dgram_sock *ro = dgram_sk(sk);
0609     struct ieee802154_addr dst_addr;
0610     DECLARE_SOCKADDR(struct sockaddr_ieee802154*, daddr, msg->msg_name);
0611     int hlen, tlen;
0612     int err;
0613 
0614     if (msg->msg_flags & MSG_OOB) {
0615         pr_debug("msg->msg_flags = 0x%x\n", msg->msg_flags);
0616         return -EOPNOTSUPP;
0617     }
0618 
0619     if (msg->msg_name) {
0620         if (ro->connected)
0621             return -EISCONN;
0622         if (msg->msg_namelen < IEEE802154_MIN_NAMELEN)
0623             return -EINVAL;
0624         err = ieee802154_sockaddr_check_size(daddr, msg->msg_namelen);
0625         if (err < 0)
0626             return err;
0627         ieee802154_addr_from_sa(&dst_addr, &daddr->addr);
0628     } else {
0629         if (!ro->connected)
0630             return -EDESTADDRREQ;
0631         dst_addr = ro->dst_addr;
0632     }
0633 
0634     if (!ro->bound)
0635         dev = dev_getfirstbyhwtype(sock_net(sk), ARPHRD_IEEE802154);
0636     else
0637         dev = ieee802154_get_dev(sock_net(sk), &ro->src_addr);
0638 
0639     if (!dev) {
0640         pr_debug("no dev\n");
0641         err = -ENXIO;
0642         goto out;
0643     }
0644     mtu = IEEE802154_MTU;
0645     pr_debug("name = %s, mtu = %u\n", dev->name, mtu);
0646 
0647     if (size > mtu) {
0648         pr_debug("size = %zu, mtu = %u\n", size, mtu);
0649         err = -EMSGSIZE;
0650         goto out_dev;
0651     }
0652 
0653     hlen = LL_RESERVED_SPACE(dev);
0654     tlen = dev->needed_tailroom;
0655     skb = sock_alloc_send_skb(sk, hlen + tlen + size,
0656                   msg->msg_flags & MSG_DONTWAIT,
0657                   &err);
0658     if (!skb)
0659         goto out_dev;
0660 
0661     skb_reserve(skb, hlen);
0662 
0663     skb_reset_network_header(skb);
0664 
0665     cb = mac_cb_init(skb);
0666     cb->type = IEEE802154_FC_TYPE_DATA;
0667     cb->ackreq = ro->want_ack;
0668     cb->secen = ro->secen;
0669     cb->secen_override = ro->secen_override;
0670     cb->seclevel = ro->seclevel;
0671     cb->seclevel_override = ro->seclevel_override;
0672 
0673     err = wpan_dev_hard_header(skb, dev, &dst_addr,
0674                    ro->bound ? &ro->src_addr : NULL, size);
0675     if (err < 0)
0676         goto out_skb;
0677 
0678     err = memcpy_from_msg(skb_put(skb, size), msg, size);
0679     if (err < 0)
0680         goto out_skb;
0681 
0682     skb->dev = dev;
0683     skb->protocol = htons(ETH_P_IEEE802154);
0684 
0685     err = dev_queue_xmit(skb);
0686     if (err > 0)
0687         err = net_xmit_errno(err);
0688 
0689     dev_put(dev);
0690 
0691     return err ?: size;
0692 
0693 out_skb:
0694     kfree_skb(skb);
0695 out_dev:
0696     dev_put(dev);
0697 out:
0698     return err;
0699 }
0700 
0701 static int dgram_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
0702              int flags, int *addr_len)
0703 {
0704     size_t copied = 0;
0705     int err = -EOPNOTSUPP;
0706     struct sk_buff *skb;
0707     struct dgram_sock *ro = dgram_sk(sk);
0708     DECLARE_SOCKADDR(struct sockaddr_ieee802154 *, saddr, msg->msg_name);
0709 
0710     skb = skb_recv_datagram(sk, flags, &err);
0711     if (!skb)
0712         goto out;
0713 
0714     copied = skb->len;
0715     if (len < copied) {
0716         msg->msg_flags |= MSG_TRUNC;
0717         copied = len;
0718     }
0719 
0720     /* FIXME: skip headers if necessary ?! */
0721     err = skb_copy_datagram_msg(skb, 0, msg, copied);
0722     if (err)
0723         goto done;
0724 
0725     sock_recv_cmsgs(msg, sk, skb);
0726 
0727     if (saddr) {
0728         /* Clear the implicit padding in struct sockaddr_ieee802154
0729          * (16 bits between 'family' and 'addr') and in struct
0730          * ieee802154_addr_sa (16 bits at the end of the structure).
0731          */
0732         memset(saddr, 0, sizeof(*saddr));
0733 
0734         saddr->family = AF_IEEE802154;
0735         ieee802154_addr_to_sa(&saddr->addr, &mac_cb(skb)->source);
0736         *addr_len = sizeof(*saddr);
0737     }
0738 
0739     if (ro->want_lqi) {
0740         err = put_cmsg(msg, SOL_IEEE802154, WPAN_WANTLQI,
0741                    sizeof(uint8_t), &(mac_cb(skb)->lqi));
0742         if (err)
0743             goto done;
0744     }
0745 
0746     if (flags & MSG_TRUNC)
0747         copied = skb->len;
0748 done:
0749     skb_free_datagram(sk, skb);
0750 out:
0751     if (err)
0752         return err;
0753     return copied;
0754 }
0755 
0756 static int dgram_rcv_skb(struct sock *sk, struct sk_buff *skb)
0757 {
0758     skb = skb_share_check(skb, GFP_ATOMIC);
0759     if (!skb)
0760         return NET_RX_DROP;
0761 
0762     if (sock_queue_rcv_skb(sk, skb) < 0) {
0763         kfree_skb(skb);
0764         return NET_RX_DROP;
0765     }
0766 
0767     return NET_RX_SUCCESS;
0768 }
0769 
0770 static inline bool
0771 ieee802154_match_sock(__le64 hw_addr, __le16 pan_id, __le16 short_addr,
0772               struct dgram_sock *ro)
0773 {
0774     if (!ro->bound)
0775         return true;
0776 
0777     if (ro->src_addr.mode == IEEE802154_ADDR_LONG &&
0778         hw_addr == ro->src_addr.extended_addr)
0779         return true;
0780 
0781     if (ro->src_addr.mode == IEEE802154_ADDR_SHORT &&
0782         pan_id == ro->src_addr.pan_id &&
0783         short_addr == ro->src_addr.short_addr)
0784         return true;
0785 
0786     return false;
0787 }
0788 
0789 static int ieee802154_dgram_deliver(struct net_device *dev, struct sk_buff *skb)
0790 {
0791     struct sock *sk, *prev = NULL;
0792     int ret = NET_RX_SUCCESS;
0793     __le16 pan_id, short_addr;
0794     __le64 hw_addr;
0795 
0796     /* Data frame processing */
0797     BUG_ON(dev->type != ARPHRD_IEEE802154);
0798 
0799     pan_id = dev->ieee802154_ptr->pan_id;
0800     short_addr = dev->ieee802154_ptr->short_addr;
0801     hw_addr = dev->ieee802154_ptr->extended_addr;
0802 
0803     read_lock(&dgram_lock);
0804     sk_for_each(sk, &dgram_head) {
0805         if (ieee802154_match_sock(hw_addr, pan_id, short_addr,
0806                       dgram_sk(sk))) {
0807             if (prev) {
0808                 struct sk_buff *clone;
0809 
0810                 clone = skb_clone(skb, GFP_ATOMIC);
0811                 if (clone)
0812                     dgram_rcv_skb(prev, clone);
0813             }
0814 
0815             prev = sk;
0816         }
0817     }
0818 
0819     if (prev) {
0820         dgram_rcv_skb(prev, skb);
0821     } else {
0822         kfree_skb(skb);
0823         ret = NET_RX_DROP;
0824     }
0825     read_unlock(&dgram_lock);
0826 
0827     return ret;
0828 }
0829 
0830 static int dgram_getsockopt(struct sock *sk, int level, int optname,
0831                 char __user *optval, int __user *optlen)
0832 {
0833     struct dgram_sock *ro = dgram_sk(sk);
0834 
0835     int val, len;
0836 
0837     if (level != SOL_IEEE802154)
0838         return -EOPNOTSUPP;
0839 
0840     if (get_user(len, optlen))
0841         return -EFAULT;
0842 
0843     len = min_t(unsigned int, len, sizeof(int));
0844 
0845     switch (optname) {
0846     case WPAN_WANTACK:
0847         val = ro->want_ack;
0848         break;
0849     case WPAN_WANTLQI:
0850         val = ro->want_lqi;
0851         break;
0852     case WPAN_SECURITY:
0853         if (!ro->secen_override)
0854             val = WPAN_SECURITY_DEFAULT;
0855         else if (ro->secen)
0856             val = WPAN_SECURITY_ON;
0857         else
0858             val = WPAN_SECURITY_OFF;
0859         break;
0860     case WPAN_SECURITY_LEVEL:
0861         if (!ro->seclevel_override)
0862             val = WPAN_SECURITY_LEVEL_DEFAULT;
0863         else
0864             val = ro->seclevel;
0865         break;
0866     default:
0867         return -ENOPROTOOPT;
0868     }
0869 
0870     if (put_user(len, optlen))
0871         return -EFAULT;
0872     if (copy_to_user(optval, &val, len))
0873         return -EFAULT;
0874     return 0;
0875 }
0876 
0877 static int dgram_setsockopt(struct sock *sk, int level, int optname,
0878                 sockptr_t optval, unsigned int optlen)
0879 {
0880     struct dgram_sock *ro = dgram_sk(sk);
0881     struct net *net = sock_net(sk);
0882     int val;
0883     int err = 0;
0884 
0885     if (optlen < sizeof(int))
0886         return -EINVAL;
0887 
0888     if (copy_from_sockptr(&val, optval, sizeof(int)))
0889         return -EFAULT;
0890 
0891     lock_sock(sk);
0892 
0893     switch (optname) {
0894     case WPAN_WANTACK:
0895         ro->want_ack = !!val;
0896         break;
0897     case WPAN_WANTLQI:
0898         ro->want_lqi = !!val;
0899         break;
0900     case WPAN_SECURITY:
0901         if (!ns_capable(net->user_ns, CAP_NET_ADMIN) &&
0902             !ns_capable(net->user_ns, CAP_NET_RAW)) {
0903             err = -EPERM;
0904             break;
0905         }
0906 
0907         switch (val) {
0908         case WPAN_SECURITY_DEFAULT:
0909             ro->secen_override = 0;
0910             break;
0911         case WPAN_SECURITY_ON:
0912             ro->secen_override = 1;
0913             ro->secen = 1;
0914             break;
0915         case WPAN_SECURITY_OFF:
0916             ro->secen_override = 1;
0917             ro->secen = 0;
0918             break;
0919         default:
0920             err = -EINVAL;
0921             break;
0922         }
0923         break;
0924     case WPAN_SECURITY_LEVEL:
0925         if (!ns_capable(net->user_ns, CAP_NET_ADMIN) &&
0926             !ns_capable(net->user_ns, CAP_NET_RAW)) {
0927             err = -EPERM;
0928             break;
0929         }
0930 
0931         if (val < WPAN_SECURITY_LEVEL_DEFAULT ||
0932             val > IEEE802154_SCF_SECLEVEL_ENC_MIC128) {
0933             err = -EINVAL;
0934         } else if (val == WPAN_SECURITY_LEVEL_DEFAULT) {
0935             ro->seclevel_override = 0;
0936         } else {
0937             ro->seclevel_override = 1;
0938             ro->seclevel = val;
0939         }
0940         break;
0941     default:
0942         err = -ENOPROTOOPT;
0943         break;
0944     }
0945 
0946     release_sock(sk);
0947     return err;
0948 }
0949 
0950 static struct proto ieee802154_dgram_prot = {
0951     .name       = "IEEE-802.15.4-MAC",
0952     .owner      = THIS_MODULE,
0953     .obj_size   = sizeof(struct dgram_sock),
0954     .init       = dgram_init,
0955     .close      = dgram_close,
0956     .bind       = dgram_bind,
0957     .sendmsg    = dgram_sendmsg,
0958     .recvmsg    = dgram_recvmsg,
0959     .hash       = dgram_hash,
0960     .unhash     = dgram_unhash,
0961     .connect    = dgram_connect,
0962     .disconnect = dgram_disconnect,
0963     .ioctl      = dgram_ioctl,
0964     .getsockopt = dgram_getsockopt,
0965     .setsockopt = dgram_setsockopt,
0966 };
0967 
0968 static const struct proto_ops ieee802154_dgram_ops = {
0969     .family        = PF_IEEE802154,
0970     .owner         = THIS_MODULE,
0971     .release       = ieee802154_sock_release,
0972     .bind          = ieee802154_sock_bind,
0973     .connect       = ieee802154_sock_connect,
0974     .socketpair    = sock_no_socketpair,
0975     .accept        = sock_no_accept,
0976     .getname       = sock_no_getname,
0977     .poll          = datagram_poll,
0978     .ioctl         = ieee802154_sock_ioctl,
0979     .gettstamp     = sock_gettstamp,
0980     .listen        = sock_no_listen,
0981     .shutdown      = sock_no_shutdown,
0982     .setsockopt    = sock_common_setsockopt,
0983     .getsockopt    = sock_common_getsockopt,
0984     .sendmsg       = ieee802154_sock_sendmsg,
0985     .recvmsg       = sock_common_recvmsg,
0986     .mmap          = sock_no_mmap,
0987     .sendpage      = sock_no_sendpage,
0988 };
0989 
0990 static void ieee802154_sock_destruct(struct sock *sk)
0991 {
0992     skb_queue_purge(&sk->sk_receive_queue);
0993 }
0994 
0995 /* Create a socket. Initialise the socket, blank the addresses
0996  * set the state.
0997  */
0998 static int ieee802154_create(struct net *net, struct socket *sock,
0999                  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);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!