~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/ieee802154/socket.c

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 = dev->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 = dev->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 = dev_hard_header(skb, dev, ETH_P_IEEE802154, &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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp