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/module.h>
32 #include <linux/types.h>
33 #include <linux/errno.h>
34 #include <linux/kernel.h>
35 #include <linux/sched.h>
36 #include <linux/slab.h>
37 #include <linux/poll.h>
38 #include <linux/fcntl.h>
39 #include <linux/init.h>
40 #include <linux/interrupt.h>
41 #include <linux/socket.h>
42 #include <linux/skbuff.h>
43 #include <linux/list.h>
44 #include <linux/device.h>
47 #include <asm/system.h>
48 #include <asm/uaccess.h>
50 #include <net/bluetooth/bluetooth.h>
51 #include <net/bluetooth/hci_core.h>
52 #include <net/bluetooth/l2cap.h>
53 #include <net/bluetooth/rfcomm.h>
55 #ifndef CONFIG_BT_RFCOMM_DEBUG
60 static const struct proto_ops rfcomm_sock_ops;
62 static struct bt_sock_list rfcomm_sk_list = {
63 .lock = __RW_LOCK_UNLOCKED(rfcomm_sk_list.lock)
66 static void rfcomm_sock_close(struct sock *sk);
67 static void rfcomm_sock_kill(struct sock *sk);
69 /* ---- DLC callbacks ----
71 * called under rfcomm_dlc_lock()
73 static void rfcomm_sk_data_ready(struct rfcomm_dlc *d, struct sk_buff *skb)
75 struct sock *sk = d->owner;
79 atomic_add(skb->len, &sk->sk_rmem_alloc);
80 skb_queue_tail(&sk->sk_receive_queue, skb);
81 sk->sk_data_ready(sk, skb->len);
83 if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
84 rfcomm_dlc_throttle(d);
87 static void rfcomm_sk_state_change(struct rfcomm_dlc *d, int err)
89 struct sock *sk = d->owner, *parent;
93 BT_DBG("dlc %p state %ld err %d", d, d->state, err);
100 sk->sk_state = d->state;
102 parent = bt_sk(sk)->parent;
104 if (d->state == BT_CLOSED) {
105 sock_set_flag(sk, SOCK_ZAPPED);
106 bt_accept_unlink(sk);
108 parent->sk_data_ready(parent, 0);
110 if (d->state == BT_CONNECTED)
111 rfcomm_session_getaddr(d->session, &bt_sk(sk)->src, NULL);
112 sk->sk_state_change(sk);
117 if (parent && sock_flag(sk, SOCK_ZAPPED)) {
118 /* We have to drop DLC lock here, otherwise
119 * rfcomm_sock_destruct() will dead lock. */
120 rfcomm_dlc_unlock(d);
121 rfcomm_sock_kill(sk);
126 /* ---- Socket functions ---- */
127 static struct sock *__rfcomm_get_sock_by_addr(u8 channel, bdaddr_t *src)
129 struct sock *sk = NULL;
130 struct hlist_node *node;
132 sk_for_each(sk, node, &rfcomm_sk_list.head) {
133 if (rfcomm_pi(sk)->channel == channel &&
134 !bacmp(&bt_sk(sk)->src, src))
138 return node ? sk : NULL;
141 /* Find socket with channel and source bdaddr.
142 * Returns closest match.
144 static struct sock *__rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
146 struct sock *sk = NULL, *sk1 = NULL;
147 struct hlist_node *node;
149 sk_for_each(sk, node, &rfcomm_sk_list.head) {
150 if (state && sk->sk_state != state)
153 if (rfcomm_pi(sk)->channel == channel) {
155 if (!bacmp(&bt_sk(sk)->src, src))
159 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
163 return node ? sk : sk1;
166 /* Find socket with given address (channel, src).
167 * Returns locked socket */
168 static inline struct sock *rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
171 read_lock(&rfcomm_sk_list.lock);
172 s = __rfcomm_get_sock_by_channel(state, channel, src);
173 if (s) bh_lock_sock(s);
174 read_unlock(&rfcomm_sk_list.lock);
178 static void rfcomm_sock_destruct(struct sock *sk)
180 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
182 BT_DBG("sk %p dlc %p", sk, d);
184 skb_queue_purge(&sk->sk_receive_queue);
185 skb_queue_purge(&sk->sk_write_queue);
188 rfcomm_pi(sk)->dlc = NULL;
190 /* Detach DLC if it's owned by this socket */
193 rfcomm_dlc_unlock(d);
198 static void rfcomm_sock_cleanup_listen(struct sock *parent)
202 BT_DBG("parent %p", parent);
204 /* Close not yet accepted dlcs */
205 while ((sk = bt_accept_dequeue(parent, NULL))) {
206 rfcomm_sock_close(sk);
207 rfcomm_sock_kill(sk);
210 parent->sk_state = BT_CLOSED;
211 sock_set_flag(parent, SOCK_ZAPPED);
214 /* Kill socket (only if zapped and orphan)
215 * Must be called on unlocked socket.
217 static void rfcomm_sock_kill(struct sock *sk)
219 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
222 BT_DBG("sk %p state %d refcnt %d", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
224 /* Kill poor orphan */
225 bt_sock_unlink(&rfcomm_sk_list, sk);
226 sock_set_flag(sk, SOCK_DEAD);
230 static void __rfcomm_sock_close(struct sock *sk)
232 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
234 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
236 switch (sk->sk_state) {
238 rfcomm_sock_cleanup_listen(sk);
245 rfcomm_dlc_close(d, 0);
248 sock_set_flag(sk, SOCK_ZAPPED);
254 * Must be called on unlocked socket.
256 static void rfcomm_sock_close(struct sock *sk)
259 __rfcomm_sock_close(sk);
263 static void rfcomm_sock_init(struct sock *sk, struct sock *parent)
265 struct rfcomm_pinfo *pi = rfcomm_pi(sk);
270 sk->sk_type = parent->sk_type;
271 pi->link_mode = rfcomm_pi(parent)->link_mode;
276 pi->dlc->link_mode = pi->link_mode;
279 static struct proto rfcomm_proto = {
281 .owner = THIS_MODULE,
282 .obj_size = sizeof(struct rfcomm_pinfo)
285 static struct sock *rfcomm_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
287 struct rfcomm_dlc *d;
290 sk = sk_alloc(net, PF_BLUETOOTH, prio, &rfcomm_proto);
294 sock_init_data(sock, sk);
295 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
297 d = rfcomm_dlc_alloc(prio);
303 d->data_ready = rfcomm_sk_data_ready;
304 d->state_change = rfcomm_sk_state_change;
306 rfcomm_pi(sk)->dlc = d;
309 sk->sk_destruct = rfcomm_sock_destruct;
310 sk->sk_sndtimeo = RFCOMM_CONN_TIMEOUT;
312 sk->sk_sndbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
313 sk->sk_rcvbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
315 sock_reset_flag(sk, SOCK_ZAPPED);
317 sk->sk_protocol = proto;
318 sk->sk_state = BT_OPEN;
320 bt_sock_link(&rfcomm_sk_list, sk);
326 static int rfcomm_sock_create(struct net *net, struct socket *sock, int protocol)
330 BT_DBG("sock %p", sock);
332 sock->state = SS_UNCONNECTED;
334 if (sock->type != SOCK_STREAM && sock->type != SOCK_RAW)
335 return -ESOCKTNOSUPPORT;
337 sock->ops = &rfcomm_sock_ops;
339 sk = rfcomm_sock_alloc(net, sock, protocol, GFP_ATOMIC);
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 d->link_mode = rfcomm_pi(sk)->link_mode;
418 err = rfcomm_dlc_open(d, &bt_sk(sk)->src, &sa->rc_bdaddr, sa->rc_channel);
420 err = bt_sock_wait_state(sk, BT_CONNECTED,
421 sock_sndtimeo(sk, flags & O_NONBLOCK));
428 static int rfcomm_sock_listen(struct socket *sock, int backlog)
430 struct sock *sk = sock->sk;
433 BT_DBG("sk %p backlog %d", sk, backlog);
437 if (sk->sk_state != BT_BOUND) {
442 if (sk->sk_type != SOCK_STREAM) {
447 if (!rfcomm_pi(sk)->channel) {
448 bdaddr_t *src = &bt_sk(sk)->src;
453 write_lock_bh(&rfcomm_sk_list.lock);
455 for (channel = 1; channel < 31; channel++)
456 if (!__rfcomm_get_sock_by_addr(channel, src)) {
457 rfcomm_pi(sk)->channel = channel;
462 write_unlock_bh(&rfcomm_sk_list.lock);
468 sk->sk_max_ack_backlog = backlog;
469 sk->sk_ack_backlog = 0;
470 sk->sk_state = BT_LISTEN;
477 static int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int flags)
479 DECLARE_WAITQUEUE(wait, current);
480 struct sock *sk = sock->sk, *nsk;
486 if (sk->sk_state != BT_LISTEN) {
491 if (sk->sk_type != SOCK_STREAM) {
496 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
498 BT_DBG("sk %p timeo %ld", sk, timeo);
500 /* Wait for an incoming connection. (wake-one). */
501 add_wait_queue_exclusive(sk->sk_sleep, &wait);
502 while (!(nsk = bt_accept_dequeue(sk, newsock))) {
503 set_current_state(TASK_INTERRUPTIBLE);
510 timeo = schedule_timeout(timeo);
513 if (sk->sk_state != BT_LISTEN) {
518 if (signal_pending(current)) {
519 err = sock_intr_errno(timeo);
523 set_current_state(TASK_RUNNING);
524 remove_wait_queue(sk->sk_sleep, &wait);
529 newsock->state = SS_CONNECTED;
531 BT_DBG("new socket %p", nsk);
538 static int rfcomm_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
540 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
541 struct sock *sk = sock->sk;
543 BT_DBG("sock %p, sk %p", sock, sk);
545 sa->rc_family = AF_BLUETOOTH;
546 sa->rc_channel = rfcomm_pi(sk)->channel;
548 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->dst);
550 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->src);
552 *len = sizeof(struct sockaddr_rc);
556 static int rfcomm_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
557 struct msghdr *msg, size_t len)
559 struct sock *sk = sock->sk;
560 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
564 if (msg->msg_flags & MSG_OOB)
567 if (sk->sk_shutdown & SEND_SHUTDOWN)
570 BT_DBG("sock %p, sk %p", sock, sk);
575 size_t size = min_t(size_t, len, d->mtu);
578 skb = sock_alloc_send_skb(sk, size + RFCOMM_SKB_RESERVE,
579 msg->msg_flags & MSG_DONTWAIT, &err);
582 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
584 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
592 err = rfcomm_dlc_send(d, skb);
609 static long rfcomm_sock_data_wait(struct sock *sk, long timeo)
611 DECLARE_WAITQUEUE(wait, current);
613 add_wait_queue(sk->sk_sleep, &wait);
615 set_current_state(TASK_INTERRUPTIBLE);
617 if (!skb_queue_empty(&sk->sk_receive_queue) ||
619 (sk->sk_shutdown & RCV_SHUTDOWN) ||
620 signal_pending(current) ||
624 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
626 timeo = schedule_timeout(timeo);
628 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
631 __set_current_state(TASK_RUNNING);
632 remove_wait_queue(sk->sk_sleep, &wait);
636 static int rfcomm_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
637 struct msghdr *msg, size_t size, int flags)
639 struct sock *sk = sock->sk;
641 size_t target, copied = 0;
647 msg->msg_namelen = 0;
649 BT_DBG("sk %p size %d", sk, size);
653 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
654 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
660 skb = skb_dequeue(&sk->sk_receive_queue);
662 if (copied >= target)
665 if ((err = sock_error(sk)) != 0)
667 if (sk->sk_shutdown & RCV_SHUTDOWN)
674 timeo = rfcomm_sock_data_wait(sk, timeo);
676 if (signal_pending(current)) {
677 err = sock_intr_errno(timeo);
683 chunk = min_t(unsigned int, skb->len, size);
684 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
685 skb_queue_head(&sk->sk_receive_queue, skb);
693 if (!(flags & MSG_PEEK)) {
694 atomic_sub(chunk, &sk->sk_rmem_alloc);
696 skb_pull(skb, chunk);
698 skb_queue_head(&sk->sk_receive_queue, skb);
704 /* put message back and return */
705 skb_queue_head(&sk->sk_receive_queue, skb);
711 if (atomic_read(&sk->sk_rmem_alloc) <= (sk->sk_rcvbuf >> 2))
712 rfcomm_dlc_unthrottle(rfcomm_pi(sk)->dlc);
715 return copied ? : err;
718 static int rfcomm_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
720 struct sock *sk = sock->sk;
730 if (get_user(opt, (u32 __user *) optval)) {
735 rfcomm_pi(sk)->link_mode = opt;
747 static int rfcomm_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
749 struct sock *sk = sock->sk;
750 struct sock *l2cap_sk;
751 struct rfcomm_conninfo cinfo;
756 if (get_user(len, optlen))
763 if (put_user(rfcomm_pi(sk)->link_mode, (u32 __user *) optval))
767 case RFCOMM_CONNINFO:
768 if (sk->sk_state != BT_CONNECTED) {
773 l2cap_sk = rfcomm_pi(sk)->dlc->session->sock->sk;
775 cinfo.hci_handle = l2cap_pi(l2cap_sk)->conn->hcon->handle;
776 memcpy(cinfo.dev_class, l2cap_pi(l2cap_sk)->conn->hcon->dev_class, 3);
778 len = min_t(unsigned int, len, sizeof(cinfo));
779 if (copy_to_user(optval, (char *) &cinfo, len))
793 static int rfcomm_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
795 struct sock *sk = sock->sk;
800 #ifdef CONFIG_BT_RFCOMM_TTY
801 err = rfcomm_dev_ioctl(sk, cmd, (void __user *)arg);
810 static int rfcomm_sock_shutdown(struct socket *sock, int how)
812 struct sock *sk = sock->sk;
815 BT_DBG("sock %p, sk %p", sock, sk);
820 if (!sk->sk_shutdown) {
821 sk->sk_shutdown = SHUTDOWN_MASK;
822 __rfcomm_sock_close(sk);
824 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
825 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
831 static int rfcomm_sock_release(struct socket *sock)
833 struct sock *sk = sock->sk;
836 BT_DBG("sock %p, sk %p", sock, sk);
841 err = rfcomm_sock_shutdown(sock, 2);
844 rfcomm_sock_kill(sk);
848 /* ---- RFCOMM core layer callbacks ----
850 * called under rfcomm_lock()
852 int rfcomm_connect_ind(struct rfcomm_session *s, u8 channel, struct rfcomm_dlc **d)
854 struct sock *sk, *parent;
858 BT_DBG("session %p channel %d", s, channel);
860 rfcomm_session_getaddr(s, &src, &dst);
862 /* Check if we have socket listening on channel */
863 parent = rfcomm_get_sock_by_channel(BT_LISTEN, channel, &src);
867 /* Check for backlog size */
868 if (sk_acceptq_is_full(parent)) {
869 BT_DBG("backlog full %d", parent->sk_ack_backlog);
873 sk = rfcomm_sock_alloc(sock_net(parent), NULL, BTPROTO_RFCOMM, GFP_ATOMIC);
877 rfcomm_sock_init(sk, parent);
878 bacpy(&bt_sk(sk)->src, &src);
879 bacpy(&bt_sk(sk)->dst, &dst);
880 rfcomm_pi(sk)->channel = channel;
882 sk->sk_state = BT_CONFIG;
883 bt_accept_enqueue(parent, sk);
885 /* Accept connection and return socket DLC */
886 *d = rfcomm_pi(sk)->dlc;
890 bh_unlock_sock(parent);
894 static ssize_t rfcomm_sock_sysfs_show(struct class *dev, char *buf)
897 struct hlist_node *node;
900 read_lock_bh(&rfcomm_sk_list.lock);
902 sk_for_each(sk, node, &rfcomm_sk_list.head) {
903 str += sprintf(str, "%s %s %d %d\n",
904 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
905 sk->sk_state, rfcomm_pi(sk)->channel);
908 read_unlock_bh(&rfcomm_sk_list.lock);
913 static CLASS_ATTR(rfcomm, S_IRUGO, rfcomm_sock_sysfs_show, NULL);
915 static const struct proto_ops rfcomm_sock_ops = {
916 .family = PF_BLUETOOTH,
917 .owner = THIS_MODULE,
918 .release = rfcomm_sock_release,
919 .bind = rfcomm_sock_bind,
920 .connect = rfcomm_sock_connect,
921 .listen = rfcomm_sock_listen,
922 .accept = rfcomm_sock_accept,
923 .getname = rfcomm_sock_getname,
924 .sendmsg = rfcomm_sock_sendmsg,
925 .recvmsg = rfcomm_sock_recvmsg,
926 .shutdown = rfcomm_sock_shutdown,
927 .setsockopt = rfcomm_sock_setsockopt,
928 .getsockopt = rfcomm_sock_getsockopt,
929 .ioctl = rfcomm_sock_ioctl,
930 .poll = bt_sock_poll,
931 .socketpair = sock_no_socketpair,
935 static struct net_proto_family rfcomm_sock_family_ops = {
936 .family = PF_BLUETOOTH,
937 .owner = THIS_MODULE,
938 .create = rfcomm_sock_create
941 int __init rfcomm_init_sockets(void)
945 err = proto_register(&rfcomm_proto, 0);
949 err = bt_sock_register(BTPROTO_RFCOMM, &rfcomm_sock_family_ops);
953 if (class_create_file(bt_class, &class_attr_rfcomm) < 0)
954 BT_ERR("Failed to create RFCOMM info file");
956 BT_INFO("RFCOMM socket layer initialized");
961 BT_ERR("RFCOMM socket layer registration failed");
962 proto_unregister(&rfcomm_proto);
966 void __exit rfcomm_cleanup_sockets(void)
968 class_remove_file(bt_class, &class_attr_rfcomm);
970 if (bt_sock_unregister(BTPROTO_RFCOMM) < 0)
971 BT_ERR("RFCOMM socket layer unregistration failed");
973 proto_unregister(&rfcomm_proto);