2 RFCOMM implementation for Linux Bluetooth stack (BlueZ).
3 Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com>
4 Copyright (C) 2002 Marcel Holtmann <marcel@holtmann.org>
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 as
8 published by the Free Software Foundation;
10 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
11 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
13 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
14 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
15 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
20 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
21 SOFTWARE IS DISCLAIMED.
27 * $Id: sock.c,v 1.24 2002/10/03 01:00:34 maxk Exp $
30 #include <linux/config.h>
31 #include <linux/module.h>
33 #include <linux/types.h>
34 #include <linux/errno.h>
35 #include <linux/kernel.h>
36 #include <linux/sched.h>
37 #include <linux/slab.h>
38 #include <linux/poll.h>
39 #include <linux/fcntl.h>
40 #include <linux/init.h>
41 #include <linux/interrupt.h>
42 #include <linux/socket.h>
43 #include <linux/skbuff.h>
44 #include <linux/list.h>
45 #include <linux/device.h>
48 #include <asm/system.h>
49 #include <asm/uaccess.h>
51 #include <net/bluetooth/bluetooth.h>
52 #include <net/bluetooth/hci_core.h>
53 #include <net/bluetooth/l2cap.h>
54 #include <net/bluetooth/rfcomm.h>
56 #ifndef CONFIG_BT_RFCOMM_DEBUG
61 static const struct proto_ops rfcomm_sock_ops;
63 static struct bt_sock_list rfcomm_sk_list = {
64 .lock = RW_LOCK_UNLOCKED
67 static void rfcomm_sock_close(struct sock *sk);
68 static void rfcomm_sock_kill(struct sock *sk);
70 /* ---- DLC callbacks ----
72 * called under rfcomm_dlc_lock()
74 static void rfcomm_sk_data_ready(struct rfcomm_dlc *d, struct sk_buff *skb)
76 struct sock *sk = d->owner;
80 atomic_add(skb->len, &sk->sk_rmem_alloc);
81 skb_queue_tail(&sk->sk_receive_queue, skb);
82 sk->sk_data_ready(sk, skb->len);
84 if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
85 rfcomm_dlc_throttle(d);
88 static void rfcomm_sk_state_change(struct rfcomm_dlc *d, int err)
90 struct sock *sk = d->owner, *parent;
94 BT_DBG("dlc %p state %ld err %d", d, d->state, err);
101 sk->sk_state = d->state;
103 parent = bt_sk(sk)->parent;
105 if (d->state == BT_CLOSED) {
106 sock_set_flag(sk, SOCK_ZAPPED);
107 bt_accept_unlink(sk);
109 parent->sk_data_ready(parent, 0);
111 if (d->state == BT_CONNECTED)
112 rfcomm_session_getaddr(d->session, &bt_sk(sk)->src, NULL);
113 sk->sk_state_change(sk);
118 if (parent && sock_flag(sk, SOCK_ZAPPED)) {
119 /* We have to drop DLC lock here, otherwise
120 * rfcomm_sock_destruct() will dead lock. */
121 rfcomm_dlc_unlock(d);
122 rfcomm_sock_kill(sk);
127 /* ---- Socket functions ---- */
128 static struct sock *__rfcomm_get_sock_by_addr(u8 channel, bdaddr_t *src)
130 struct sock *sk = NULL;
131 struct hlist_node *node;
133 sk_for_each(sk, node, &rfcomm_sk_list.head) {
134 if (rfcomm_pi(sk)->channel == channel &&
135 !bacmp(&bt_sk(sk)->src, src))
139 return node ? sk : NULL;
142 /* Find socket with channel and source bdaddr.
143 * Returns closest match.
145 static struct sock *__rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
147 struct sock *sk = NULL, *sk1 = NULL;
148 struct hlist_node *node;
150 sk_for_each(sk, node, &rfcomm_sk_list.head) {
151 if (state && sk->sk_state != state)
154 if (rfcomm_pi(sk)->channel == channel) {
156 if (!bacmp(&bt_sk(sk)->src, src))
160 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
164 return node ? sk : sk1;
167 /* Find socket with given address (channel, src).
168 * Returns locked socket */
169 static inline struct sock *rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
172 read_lock(&rfcomm_sk_list.lock);
173 s = __rfcomm_get_sock_by_channel(state, channel, src);
174 if (s) bh_lock_sock(s);
175 read_unlock(&rfcomm_sk_list.lock);
179 static void rfcomm_sock_destruct(struct sock *sk)
181 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
183 BT_DBG("sk %p dlc %p", sk, d);
185 skb_queue_purge(&sk->sk_receive_queue);
186 skb_queue_purge(&sk->sk_write_queue);
189 rfcomm_pi(sk)->dlc = NULL;
191 /* Detach DLC if it's owned by this socket */
194 rfcomm_dlc_unlock(d);
199 static void rfcomm_sock_cleanup_listen(struct sock *parent)
203 BT_DBG("parent %p", parent);
205 /* Close not yet accepted dlcs */
206 while ((sk = bt_accept_dequeue(parent, NULL))) {
207 rfcomm_sock_close(sk);
208 rfcomm_sock_kill(sk);
211 parent->sk_state = BT_CLOSED;
212 sock_set_flag(parent, SOCK_ZAPPED);
215 /* Kill socket (only if zapped and orphan)
216 * Must be called on unlocked socket.
218 static void rfcomm_sock_kill(struct sock *sk)
220 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
223 BT_DBG("sk %p state %d refcnt %d", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
225 /* Kill poor orphan */
226 bt_sock_unlink(&rfcomm_sk_list, sk);
227 sock_set_flag(sk, SOCK_DEAD);
231 static void __rfcomm_sock_close(struct sock *sk)
233 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
235 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
237 switch (sk->sk_state) {
239 rfcomm_sock_cleanup_listen(sk);
246 rfcomm_dlc_close(d, 0);
249 sock_set_flag(sk, SOCK_ZAPPED);
255 * Must be called on unlocked socket.
257 static void rfcomm_sock_close(struct sock *sk)
260 __rfcomm_sock_close(sk);
264 static void rfcomm_sock_init(struct sock *sk, struct sock *parent)
266 struct rfcomm_pinfo *pi = rfcomm_pi(sk);
271 sk->sk_type = parent->sk_type;
272 pi->link_mode = rfcomm_pi(parent)->link_mode;
277 pi->dlc->link_mode = pi->link_mode;
280 static struct proto rfcomm_proto = {
282 .owner = THIS_MODULE,
283 .obj_size = sizeof(struct rfcomm_pinfo)
286 static struct sock *rfcomm_sock_alloc(struct socket *sock, int proto, gfp_t prio)
288 struct rfcomm_dlc *d;
291 sk = sk_alloc(PF_BLUETOOTH, prio, &rfcomm_proto, 1);
295 sock_init_data(sock, sk);
296 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
298 d = rfcomm_dlc_alloc(prio);
304 d->data_ready = rfcomm_sk_data_ready;
305 d->state_change = rfcomm_sk_state_change;
307 rfcomm_pi(sk)->dlc = d;
310 sk->sk_destruct = rfcomm_sock_destruct;
311 sk->sk_sndtimeo = RFCOMM_CONN_TIMEOUT;
313 sk->sk_sndbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
314 sk->sk_rcvbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
316 sock_reset_flag(sk, SOCK_ZAPPED);
318 sk->sk_protocol = proto;
319 sk->sk_state = BT_OPEN;
321 bt_sock_link(&rfcomm_sk_list, sk);
327 static int rfcomm_sock_create(struct socket *sock, int protocol)
331 BT_DBG("sock %p", sock);
333 sock->state = SS_UNCONNECTED;
335 if (sock->type != SOCK_STREAM && sock->type != SOCK_RAW)
336 return -ESOCKTNOSUPPORT;
338 sock->ops = &rfcomm_sock_ops;
340 if (!(sk = rfcomm_sock_alloc(sock, protocol, GFP_KERNEL)))
343 rfcomm_sock_init(sk, NULL);
347 static int rfcomm_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
349 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
350 struct sock *sk = sock->sk;
353 BT_DBG("sk %p %s", sk, batostr(&sa->rc_bdaddr));
355 if (!addr || addr->sa_family != AF_BLUETOOTH)
360 if (sk->sk_state != BT_OPEN) {
365 if (sk->sk_type != SOCK_STREAM) {
370 write_lock_bh(&rfcomm_sk_list.lock);
372 if (sa->rc_channel && __rfcomm_get_sock_by_addr(sa->rc_channel, &sa->rc_bdaddr)) {
375 /* Save source address */
376 bacpy(&bt_sk(sk)->src, &sa->rc_bdaddr);
377 rfcomm_pi(sk)->channel = sa->rc_channel;
378 sk->sk_state = BT_BOUND;
381 write_unlock_bh(&rfcomm_sk_list.lock);
388 static int rfcomm_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
390 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
391 struct sock *sk = sock->sk;
392 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
397 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_rc))
402 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
407 if (sk->sk_type != SOCK_STREAM) {
412 sk->sk_state = BT_CONNECT;
413 bacpy(&bt_sk(sk)->dst, &sa->rc_bdaddr);
414 rfcomm_pi(sk)->channel = sa->rc_channel;
416 err = rfcomm_dlc_open(d, &bt_sk(sk)->src, &sa->rc_bdaddr, sa->rc_channel);
418 err = bt_sock_wait_state(sk, BT_CONNECTED,
419 sock_sndtimeo(sk, flags & O_NONBLOCK));
426 static int rfcomm_sock_listen(struct socket *sock, int backlog)
428 struct sock *sk = sock->sk;
431 BT_DBG("sk %p backlog %d", sk, backlog);
435 if (sk->sk_state != BT_BOUND) {
440 if (sk->sk_type != SOCK_STREAM) {
445 if (!rfcomm_pi(sk)->channel) {
446 bdaddr_t *src = &bt_sk(sk)->src;
451 write_lock_bh(&rfcomm_sk_list.lock);
453 for (channel = 1; channel < 31; channel++)
454 if (!__rfcomm_get_sock_by_addr(channel, src)) {
455 rfcomm_pi(sk)->channel = channel;
460 write_unlock_bh(&rfcomm_sk_list.lock);
466 sk->sk_max_ack_backlog = backlog;
467 sk->sk_ack_backlog = 0;
468 sk->sk_state = BT_LISTEN;
475 static int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int flags)
477 DECLARE_WAITQUEUE(wait, current);
478 struct sock *sk = sock->sk, *nsk;
484 if (sk->sk_state != BT_LISTEN) {
489 if (sk->sk_type != SOCK_STREAM) {
494 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
496 BT_DBG("sk %p timeo %ld", sk, timeo);
498 /* Wait for an incoming connection. (wake-one). */
499 add_wait_queue_exclusive(sk->sk_sleep, &wait);
500 while (!(nsk = bt_accept_dequeue(sk, newsock))) {
501 set_current_state(TASK_INTERRUPTIBLE);
508 timeo = schedule_timeout(timeo);
511 if (sk->sk_state != BT_LISTEN) {
516 if (signal_pending(current)) {
517 err = sock_intr_errno(timeo);
521 set_current_state(TASK_RUNNING);
522 remove_wait_queue(sk->sk_sleep, &wait);
527 newsock->state = SS_CONNECTED;
529 BT_DBG("new socket %p", nsk);
536 static int rfcomm_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
538 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
539 struct sock *sk = sock->sk;
541 BT_DBG("sock %p, sk %p", sock, sk);
543 sa->rc_family = AF_BLUETOOTH;
544 sa->rc_channel = rfcomm_pi(sk)->channel;
546 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->dst);
548 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->src);
550 *len = sizeof(struct sockaddr_rc);
554 static int rfcomm_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
555 struct msghdr *msg, size_t len)
557 struct sock *sk = sock->sk;
558 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
562 if (msg->msg_flags & MSG_OOB)
565 if (sk->sk_shutdown & SEND_SHUTDOWN)
568 BT_DBG("sock %p, sk %p", sock, sk);
573 size_t size = min_t(size_t, len, d->mtu);
576 skb = sock_alloc_send_skb(sk, size + RFCOMM_SKB_RESERVE,
577 msg->msg_flags & MSG_DONTWAIT, &err);
580 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
582 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
590 err = rfcomm_dlc_send(d, skb);
607 static long rfcomm_sock_data_wait(struct sock *sk, long timeo)
609 DECLARE_WAITQUEUE(wait, current);
611 add_wait_queue(sk->sk_sleep, &wait);
613 set_current_state(TASK_INTERRUPTIBLE);
615 if (!skb_queue_empty(&sk->sk_receive_queue) ||
617 (sk->sk_shutdown & RCV_SHUTDOWN) ||
618 signal_pending(current) ||
622 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
624 timeo = schedule_timeout(timeo);
626 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
629 __set_current_state(TASK_RUNNING);
630 remove_wait_queue(sk->sk_sleep, &wait);
634 static int rfcomm_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
635 struct msghdr *msg, size_t size, int flags)
637 struct sock *sk = sock->sk;
639 size_t target, copied = 0;
645 msg->msg_namelen = 0;
647 BT_DBG("sk %p size %d", sk, size);
651 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
652 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
658 skb = skb_dequeue(&sk->sk_receive_queue);
660 if (copied >= target)
663 if ((err = sock_error(sk)) != 0)
665 if (sk->sk_shutdown & RCV_SHUTDOWN)
672 timeo = rfcomm_sock_data_wait(sk, timeo);
674 if (signal_pending(current)) {
675 err = sock_intr_errno(timeo);
681 chunk = min_t(unsigned int, skb->len, size);
682 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
683 skb_queue_head(&sk->sk_receive_queue, skb);
691 if (!(flags & MSG_PEEK)) {
692 atomic_sub(chunk, &sk->sk_rmem_alloc);
694 skb_pull(skb, chunk);
696 skb_queue_head(&sk->sk_receive_queue, skb);
702 /* put message back and return */
703 skb_queue_head(&sk->sk_receive_queue, skb);
709 if (atomic_read(&sk->sk_rmem_alloc) <= (sk->sk_rcvbuf >> 2))
710 rfcomm_dlc_unthrottle(rfcomm_pi(sk)->dlc);
713 return copied ? : err;
716 static int rfcomm_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
718 struct sock *sk = sock->sk;
728 if (get_user(opt, (u32 __user *) optval)) {
733 rfcomm_pi(sk)->link_mode = opt;
745 static int rfcomm_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
747 struct sock *sk = sock->sk;
748 struct sock *l2cap_sk;
749 struct rfcomm_conninfo cinfo;
754 if (get_user(len, optlen))
761 if (put_user(rfcomm_pi(sk)->link_mode, (u32 __user *) optval))
765 case RFCOMM_CONNINFO:
766 if (sk->sk_state != BT_CONNECTED) {
771 l2cap_sk = rfcomm_pi(sk)->dlc->session->sock->sk;
773 cinfo.hci_handle = l2cap_pi(l2cap_sk)->conn->hcon->handle;
774 memcpy(cinfo.dev_class, l2cap_pi(l2cap_sk)->conn->hcon->dev_class, 3);
776 len = min_t(unsigned int, len, sizeof(cinfo));
777 if (copy_to_user(optval, (char *) &cinfo, len))
791 static int rfcomm_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
793 struct sock *sk = sock->sk;
798 #ifdef CONFIG_BT_RFCOMM_TTY
799 err = rfcomm_dev_ioctl(sk, cmd, (void __user *)arg);
808 static int rfcomm_sock_shutdown(struct socket *sock, int how)
810 struct sock *sk = sock->sk;
813 BT_DBG("sock %p, sk %p", sock, sk);
818 if (!sk->sk_shutdown) {
819 sk->sk_shutdown = SHUTDOWN_MASK;
820 __rfcomm_sock_close(sk);
822 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
823 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
829 static int rfcomm_sock_release(struct socket *sock)
831 struct sock *sk = sock->sk;
834 BT_DBG("sock %p, sk %p", sock, sk);
839 err = rfcomm_sock_shutdown(sock, 2);
842 rfcomm_sock_kill(sk);
846 /* ---- RFCOMM core layer callbacks ----
848 * called under rfcomm_lock()
850 int rfcomm_connect_ind(struct rfcomm_session *s, u8 channel, struct rfcomm_dlc **d)
852 struct sock *sk, *parent;
856 BT_DBG("session %p channel %d", s, channel);
858 rfcomm_session_getaddr(s, &src, &dst);
860 /* Check if we have socket listening on channel */
861 parent = rfcomm_get_sock_by_channel(BT_LISTEN, channel, &src);
865 /* Check for backlog size */
866 if (sk_acceptq_is_full(parent)) {
867 BT_DBG("backlog full %d", parent->sk_ack_backlog);
871 sk = rfcomm_sock_alloc(NULL, BTPROTO_RFCOMM, GFP_ATOMIC);
875 rfcomm_sock_init(sk, parent);
876 bacpy(&bt_sk(sk)->src, &src);
877 bacpy(&bt_sk(sk)->dst, &dst);
878 rfcomm_pi(sk)->channel = channel;
880 sk->sk_state = BT_CONFIG;
881 bt_accept_enqueue(parent, sk);
883 /* Accept connection and return socket DLC */
884 *d = rfcomm_pi(sk)->dlc;
888 bh_unlock_sock(parent);
892 static ssize_t rfcomm_sock_sysfs_show(struct class *dev, char *buf)
895 struct hlist_node *node;
898 read_lock_bh(&rfcomm_sk_list.lock);
900 sk_for_each(sk, node, &rfcomm_sk_list.head) {
901 str += sprintf(str, "%s %s %d %d\n",
902 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
903 sk->sk_state, rfcomm_pi(sk)->channel);
906 read_unlock_bh(&rfcomm_sk_list.lock);
911 static CLASS_ATTR(rfcomm, S_IRUGO, rfcomm_sock_sysfs_show, NULL);
913 static const struct proto_ops rfcomm_sock_ops = {
914 .family = PF_BLUETOOTH,
915 .owner = THIS_MODULE,
916 .release = rfcomm_sock_release,
917 .bind = rfcomm_sock_bind,
918 .connect = rfcomm_sock_connect,
919 .listen = rfcomm_sock_listen,
920 .accept = rfcomm_sock_accept,
921 .getname = rfcomm_sock_getname,
922 .sendmsg = rfcomm_sock_sendmsg,
923 .recvmsg = rfcomm_sock_recvmsg,
924 .shutdown = rfcomm_sock_shutdown,
925 .setsockopt = rfcomm_sock_setsockopt,
926 .getsockopt = rfcomm_sock_getsockopt,
927 .ioctl = rfcomm_sock_ioctl,
928 .poll = bt_sock_poll,
929 .socketpair = sock_no_socketpair,
933 static struct net_proto_family rfcomm_sock_family_ops = {
934 .family = PF_BLUETOOTH,
935 .owner = THIS_MODULE,
936 .create = rfcomm_sock_create
939 int __init rfcomm_init_sockets(void)
943 err = proto_register(&rfcomm_proto, 0);
947 err = bt_sock_register(BTPROTO_RFCOMM, &rfcomm_sock_family_ops);
951 class_create_file(&bt_class, &class_attr_rfcomm);
953 BT_INFO("RFCOMM socket layer initialized");
958 BT_ERR("RFCOMM socket layer registration failed");
959 proto_unregister(&rfcomm_proto);
963 void __exit rfcomm_cleanup_sockets(void)
965 class_remove_file(&bt_class, &class_attr_rfcomm);
967 if (bt_sock_unregister(BTPROTO_RFCOMM) < 0)
968 BT_ERR("RFCOMM socket layer unregistration failed");
970 proto_unregister(&rfcomm_proto);