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/major.h>
37 #include <linux/sched.h>
38 #include <linux/slab.h>
39 #include <linux/poll.h>
40 #include <linux/fcntl.h>
41 #include <linux/init.h>
42 #include <linux/interrupt.h>
43 #include <linux/socket.h>
44 #include <linux/skbuff.h>
45 #include <linux/list.h>
46 #include <linux/proc_fs.h>
47 #include <linux/seq_file.h>
50 #include <asm/system.h>
51 #include <asm/uaccess.h>
53 #include <net/bluetooth/bluetooth.h>
54 #include <net/bluetooth/rfcomm.h>
56 #ifndef CONFIG_BT_RFCOMM_DEBUG
61 static 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);
100 sk->sk_state = d->state;
102 parent = bt_sk(sk)->parent;
104 if (d->state == BT_CONNECTED)
105 rfcomm_session_getaddr(d->session, &bt_sk(sk)->src, NULL);
106 sk->sk_state_change(sk);
108 parent->sk_data_ready(parent, 0);
113 /* ---- Socket functions ---- */
114 static struct sock *__rfcomm_get_sock_by_addr(u8 channel, bdaddr_t *src)
116 struct sock *sk = NULL;
117 struct hlist_node *node;
119 sk_for_each(sk, node, &rfcomm_sk_list.head) {
120 if (rfcomm_pi(sk)->channel == channel &&
121 !bacmp(&bt_sk(sk)->src, src))
125 return node ? sk : NULL;
128 /* Find socket with channel and source bdaddr.
129 * Returns closest match.
131 static struct sock *__rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
133 struct sock *sk = NULL, *sk1 = NULL;
134 struct hlist_node *node;
136 sk_for_each(sk, node, &rfcomm_sk_list.head) {
137 if (state && sk->sk_state != state)
140 if (rfcomm_pi(sk)->channel == channel) {
142 if (!bacmp(&bt_sk(sk)->src, src))
146 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
150 return node ? sk : sk1;
153 /* Find socket with given address (channel, src).
154 * Returns locked socket */
155 static inline struct sock *rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
158 read_lock(&rfcomm_sk_list.lock);
159 s = __rfcomm_get_sock_by_channel(state, channel, src);
160 if (s) bh_lock_sock(s);
161 read_unlock(&rfcomm_sk_list.lock);
165 static void rfcomm_sock_destruct(struct sock *sk)
167 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
169 BT_DBG("sk %p dlc %p", sk, d);
171 skb_queue_purge(&sk->sk_receive_queue);
172 skb_queue_purge(&sk->sk_write_queue);
175 rfcomm_pi(sk)->dlc = NULL;
177 /* Detach DLC if it's owned by this socket */
180 rfcomm_dlc_unlock(d);
185 kfree(sk->sk_protinfo);
188 static void rfcomm_sock_cleanup_listen(struct sock *parent)
192 BT_DBG("parent %p", parent);
194 /* Close not yet accepted dlcs */
195 while ((sk = bt_accept_dequeue(parent, NULL))) {
196 rfcomm_sock_close(sk);
197 rfcomm_sock_kill(sk);
200 parent->sk_state = BT_CLOSED;
201 parent->sk_zapped = 1;
204 /* Kill socket (only if zapped and orphan)
205 * Must be called on unlocked socket.
207 static void rfcomm_sock_kill(struct sock *sk)
209 if (!sk->sk_zapped || sk->sk_socket)
212 BT_DBG("sk %p state %d refcnt %d", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
214 /* Kill poor orphan */
215 bt_sock_unlink(&rfcomm_sk_list, sk);
216 sock_set_flag(sk, SOCK_DEAD);
220 static void __rfcomm_sock_close(struct sock *sk)
222 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
224 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
226 switch (sk->sk_state) {
228 rfcomm_sock_cleanup_listen(sk);
235 rfcomm_dlc_close(d, 0);
244 * Must be called on unlocked socket.
246 static void rfcomm_sock_close(struct sock *sk)
249 __rfcomm_sock_close(sk);
253 static void rfcomm_sock_init(struct sock *sk, struct sock *parent)
258 sk->sk_type = parent->sk_type;
261 static struct sock *rfcomm_sock_alloc(struct socket *sock, int proto, int prio)
263 struct rfcomm_dlc *d;
266 sk = bt_sock_alloc(sock, BTPROTO_RFCOMM, sizeof(struct rfcomm_pinfo), prio);
270 sk_set_owner(sk, THIS_MODULE);
272 d = rfcomm_dlc_alloc(prio);
277 d->data_ready = rfcomm_sk_data_ready;
278 d->state_change = rfcomm_sk_state_change;
280 rfcomm_pi(sk)->dlc = d;
283 sk->sk_destruct = rfcomm_sock_destruct;
284 sk->sk_sndtimeo = RFCOMM_CONN_TIMEOUT;
286 sk->sk_sndbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
287 sk->sk_rcvbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
289 sk->sk_protocol = proto;
290 sk->sk_state = BT_OPEN;
292 bt_sock_link(&rfcomm_sk_list, sk);
298 static int rfcomm_sock_create(struct socket *sock, int protocol)
302 BT_DBG("sock %p", sock);
304 sock->state = SS_UNCONNECTED;
306 if (sock->type != SOCK_STREAM && sock->type != SOCK_RAW)
307 return -ESOCKTNOSUPPORT;
309 sock->ops = &rfcomm_sock_ops;
311 if (!(sk = rfcomm_sock_alloc(sock, protocol, GFP_KERNEL)))
314 rfcomm_sock_init(sk, NULL);
318 static int rfcomm_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
320 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
321 struct sock *sk = sock->sk;
324 BT_DBG("sk %p %s", sk, batostr(&sa->rc_bdaddr));
326 if (!addr || addr->sa_family != AF_BLUETOOTH)
331 if (sk->sk_state != BT_OPEN) {
336 write_lock_bh(&rfcomm_sk_list.lock);
338 if (sa->rc_channel && __rfcomm_get_sock_by_addr(sa->rc_channel, &sa->rc_bdaddr)) {
341 /* Save source address */
342 bacpy(&bt_sk(sk)->src, &sa->rc_bdaddr);
343 rfcomm_pi(sk)->channel = sa->rc_channel;
344 sk->sk_state = BT_BOUND;
347 write_unlock_bh(&rfcomm_sk_list.lock);
354 static int rfcomm_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
356 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
357 struct sock *sk = sock->sk;
358 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
363 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_rc))
366 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
369 if (sk->sk_type != SOCK_STREAM)
374 sk->sk_state = BT_CONNECT;
375 bacpy(&bt_sk(sk)->dst, &sa->rc_bdaddr);
376 rfcomm_pi(sk)->channel = sa->rc_channel;
378 err = rfcomm_dlc_open(d, &bt_sk(sk)->src, &sa->rc_bdaddr, sa->rc_channel);
380 err = bt_sock_wait_state(sk, BT_CONNECTED,
381 sock_sndtimeo(sk, flags & O_NONBLOCK));
387 int rfcomm_sock_listen(struct socket *sock, int backlog)
389 struct sock *sk = sock->sk;
392 BT_DBG("sk %p backlog %d", sk, backlog);
396 if (sk->sk_state != BT_BOUND) {
401 sk->sk_max_ack_backlog = backlog;
402 sk->sk_ack_backlog = 0;
403 sk->sk_state = BT_LISTEN;
410 int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int flags)
412 DECLARE_WAITQUEUE(wait, current);
413 struct sock *sk = sock->sk, *nsk;
419 if (sk->sk_state != BT_LISTEN) {
424 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
426 BT_DBG("sk %p timeo %ld", sk, timeo);
428 /* Wait for an incoming connection. (wake-one). */
429 add_wait_queue_exclusive(sk->sk_sleep, &wait);
430 while (!(nsk = bt_accept_dequeue(sk, newsock))) {
431 set_current_state(TASK_INTERRUPTIBLE);
438 timeo = schedule_timeout(timeo);
441 if (sk->sk_state != BT_LISTEN) {
446 if (signal_pending(current)) {
447 err = sock_intr_errno(timeo);
451 set_current_state(TASK_RUNNING);
452 remove_wait_queue(sk->sk_sleep, &wait);
457 newsock->state = SS_CONNECTED;
459 BT_DBG("new socket %p", nsk);
466 static int rfcomm_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
468 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
469 struct sock *sk = sock->sk;
471 BT_DBG("sock %p, sk %p", sock, sk);
473 sa->rc_family = AF_BLUETOOTH;
474 sa->rc_channel = rfcomm_pi(sk)->channel;
476 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->dst);
478 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->src);
480 *len = sizeof(struct sockaddr_rc);
484 static int rfcomm_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
485 struct msghdr *msg, size_t len)
487 struct sock *sk = sock->sk;
488 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
493 if (msg->msg_flags & MSG_OOB)
496 if (sk->sk_shutdown & SEND_SHUTDOWN)
499 BT_DBG("sock %p, sk %p", sock, sk);
504 size_t size = min_t(size_t, len, d->mtu);
506 skb = sock_alloc_send_skb(sk, size + RFCOMM_SKB_RESERVE,
507 msg->msg_flags & MSG_DONTWAIT, &err);
510 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
512 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
519 err = rfcomm_dlc_send(d, skb);
531 return sent ? sent : err;
534 static long rfcomm_sock_data_wait(struct sock *sk, long timeo)
536 DECLARE_WAITQUEUE(wait, current);
538 add_wait_queue(sk->sk_sleep, &wait);
540 set_current_state(TASK_INTERRUPTIBLE);
542 if (skb_queue_len(&sk->sk_receive_queue) || sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN) ||
543 signal_pending(current) || !timeo)
546 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
548 timeo = schedule_timeout(timeo);
550 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
553 __set_current_state(TASK_RUNNING);
554 remove_wait_queue(sk->sk_sleep, &wait);
558 static int rfcomm_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
559 struct msghdr *msg, size_t size, int flags)
561 struct sock *sk = sock->sk;
563 size_t target, copied = 0;
569 msg->msg_namelen = 0;
571 BT_DBG("sk %p size %d", sk, size);
575 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
576 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
582 skb = skb_dequeue(&sk->sk_receive_queue);
584 if (copied >= target)
587 if ((err = sock_error(sk)) != 0)
589 if (sk->sk_shutdown & RCV_SHUTDOWN)
596 timeo = rfcomm_sock_data_wait(sk, timeo);
598 if (signal_pending(current)) {
599 err = sock_intr_errno(timeo);
605 chunk = min_t(unsigned int, skb->len, size);
606 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
607 skb_queue_head(&sk->sk_receive_queue, skb);
615 if (!(flags & MSG_PEEK)) {
616 atomic_sub(chunk, &sk->sk_rmem_alloc);
618 skb_pull(skb, chunk);
620 skb_queue_head(&sk->sk_receive_queue, skb);
626 /* put message back and return */
627 skb_queue_head(&sk->sk_receive_queue, skb);
633 if (atomic_read(&sk->sk_rmem_alloc) <= (sk->sk_rcvbuf >> 2))
634 rfcomm_dlc_unthrottle(rfcomm_pi(sk)->dlc);
637 return copied ? : err;
640 static int rfcomm_sock_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen)
642 struct sock *sk = sock->sk;
659 static int rfcomm_sock_getsockopt(struct socket *sock, int level, int optname, char *optval, int *optlen)
661 struct sock *sk = sock->sk;
666 if (get_user(len, optlen))
681 static int rfcomm_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
683 struct sock *sk = sock->sk;
688 #ifdef CONFIG_BT_RFCOMM_TTY
689 err = rfcomm_dev_ioctl(sk, cmd, arg);
698 static int rfcomm_sock_shutdown(struct socket *sock, int how)
700 struct sock *sk = sock->sk;
703 BT_DBG("sock %p, sk %p", sock, sk);
708 if (!sk->sk_shutdown) {
709 sk->sk_shutdown = SHUTDOWN_MASK;
710 __rfcomm_sock_close(sk);
712 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
713 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
719 static int rfcomm_sock_release(struct socket *sock)
721 struct sock *sk = sock->sk;
724 BT_DBG("sock %p, sk %p", sock, sk);
729 err = rfcomm_sock_shutdown(sock, 2);
732 rfcomm_sock_kill(sk);
736 /* ---- RFCOMM core layer callbacks ----
738 * called under rfcomm_lock()
740 int rfcomm_connect_ind(struct rfcomm_session *s, u8 channel, struct rfcomm_dlc **d)
742 struct sock *sk, *parent;
746 BT_DBG("session %p channel %d", s, channel);
748 rfcomm_session_getaddr(s, &src, &dst);
750 /* Check if we have socket listening on channel */
751 parent = rfcomm_get_sock_by_channel(BT_LISTEN, channel, &src);
755 /* Check for backlog size */
756 if (parent->sk_ack_backlog > parent->sk_max_ack_backlog) {
757 BT_DBG("backlog full %d", parent->sk_ack_backlog);
761 sk = rfcomm_sock_alloc(NULL, BTPROTO_RFCOMM, GFP_ATOMIC);
765 rfcomm_sock_init(sk, parent);
766 bacpy(&bt_sk(sk)->src, &src);
767 bacpy(&bt_sk(sk)->dst, &dst);
768 rfcomm_pi(sk)->channel = channel;
770 sk->sk_state = BT_CONFIG;
771 bt_accept_enqueue(parent, sk);
773 /* Accept connection and return socket DLC */
774 *d = rfcomm_pi(sk)->dlc;
778 bh_unlock_sock(parent);
782 /* ---- Proc fs support ---- */
783 #ifdef CONFIG_PROC_FS
784 static void *rfcomm_seq_start(struct seq_file *seq, loff_t *pos)
787 struct hlist_node *node;
790 read_lock_bh(&rfcomm_sk_list.lock);
792 sk_for_each(sk, node, &rfcomm_sk_list.head)
798 static void *rfcomm_seq_next(struct seq_file *seq, void *e, loff_t *pos)
805 static void rfcomm_seq_stop(struct seq_file *seq, void *e)
807 read_unlock_bh(&rfcomm_sk_list.lock);
810 static int rfcomm_seq_show(struct seq_file *seq, void *e)
813 seq_printf(seq, "%s %s %d %d\n",
814 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
815 sk->sk_state, rfcomm_pi(sk)->channel);
819 static struct seq_operations rfcomm_seq_ops = {
820 .start = rfcomm_seq_start,
821 .next = rfcomm_seq_next,
822 .stop = rfcomm_seq_stop,
823 .show = rfcomm_seq_show
826 static int rfcomm_seq_open(struct inode *inode, struct file *file)
828 return seq_open(file, &rfcomm_seq_ops);
831 static struct file_operations rfcomm_seq_fops = {
832 .owner = THIS_MODULE,
833 .open = rfcomm_seq_open,
836 .release = seq_release,
839 static int __init rfcomm_sock_proc_init(void)
841 struct proc_dir_entry *p = create_proc_entry("sock", S_IRUGO, proc_bt_rfcomm);
844 p->proc_fops = &rfcomm_seq_fops;
848 static void __exit rfcomm_sock_proc_cleanup(void)
850 remove_proc_entry("sock", proc_bt_rfcomm);
853 #else /* CONFIG_PROC_FS */
855 static int __init rfcomm_sock_proc_init(void)
860 static void __exit rfcomm_sock_proc_cleanup(void)
864 #endif /* CONFIG_PROC_FS */
866 static struct proto_ops rfcomm_sock_ops = {
867 .family = PF_BLUETOOTH,
868 .owner = THIS_MODULE,
869 .release = rfcomm_sock_release,
870 .bind = rfcomm_sock_bind,
871 .connect = rfcomm_sock_connect,
872 .listen = rfcomm_sock_listen,
873 .accept = rfcomm_sock_accept,
874 .getname = rfcomm_sock_getname,
875 .sendmsg = rfcomm_sock_sendmsg,
876 .recvmsg = rfcomm_sock_recvmsg,
877 .shutdown = rfcomm_sock_shutdown,
878 .setsockopt = rfcomm_sock_setsockopt,
879 .getsockopt = rfcomm_sock_getsockopt,
880 .ioctl = rfcomm_sock_ioctl,
881 .poll = bt_sock_poll,
882 .socketpair = sock_no_socketpair,
886 static struct net_proto_family rfcomm_sock_family_ops = {
887 .family = PF_BLUETOOTH,
888 .owner = THIS_MODULE,
889 .create = rfcomm_sock_create
892 int __init rfcomm_init_sockets(void)
896 if ((err = bt_sock_register(BTPROTO_RFCOMM, &rfcomm_sock_family_ops))) {
897 BT_ERR("RFCOMM socket layer registration failed. %d", err);
901 rfcomm_sock_proc_init();
903 BT_INFO("RFCOMM socket layer initialized");
907 void __exit rfcomm_cleanup_sockets(void)
911 rfcomm_sock_proc_cleanup();
913 /* Unregister socket, protocol and notifier */
914 if ((err = bt_sock_unregister(BTPROTO_RFCOMM)))
915 BT_ERR("RFCOMM socket layer unregistration failed. %d", err);