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.
28 #include <linux/export.h>
29 #include <linux/debugfs.h>
30 #include <linux/sched/signal.h>
32 #include <net/bluetooth/bluetooth.h>
33 #include <net/bluetooth/hci_core.h>
34 #include <net/bluetooth/l2cap.h>
35 #include <net/bluetooth/rfcomm.h>
37 static const struct proto_ops rfcomm_sock_ops;
39 static struct bt_sock_list rfcomm_sk_list = {
40 .lock = __RW_LOCK_UNLOCKED(rfcomm_sk_list.lock)
43 static void rfcomm_sock_close(struct sock *sk);
44 static void rfcomm_sock_kill(struct sock *sk);
46 /* ---- DLC callbacks ----
48 * called under rfcomm_dlc_lock()
50 static void rfcomm_sk_data_ready(struct rfcomm_dlc *d, struct sk_buff *skb)
52 struct sock *sk = d->owner;
56 atomic_add(skb->len, &sk->sk_rmem_alloc);
57 skb_queue_tail(&sk->sk_receive_queue, skb);
58 sk->sk_data_ready(sk);
60 if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
61 rfcomm_dlc_throttle(d);
64 static void rfcomm_sk_state_change(struct rfcomm_dlc *d, int err)
66 struct sock *sk = d->owner, *parent;
72 BT_DBG("dlc %p state %ld err %d", d, d->state, err);
74 local_irq_save(flags);
80 sk->sk_state = d->state;
82 parent = bt_sk(sk)->parent;
84 if (d->state == BT_CLOSED) {
85 sock_set_flag(sk, SOCK_ZAPPED);
88 parent->sk_data_ready(parent);
90 if (d->state == BT_CONNECTED)
91 rfcomm_session_getaddr(d->session,
92 &rfcomm_pi(sk)->src, NULL);
93 sk->sk_state_change(sk);
97 local_irq_restore(flags);
99 if (parent && sock_flag(sk, SOCK_ZAPPED)) {
100 /* We have to drop DLC lock here, otherwise
101 * rfcomm_sock_destruct() will dead lock. */
102 rfcomm_dlc_unlock(d);
103 rfcomm_sock_kill(sk);
108 /* ---- Socket functions ---- */
109 static struct sock *__rfcomm_get_listen_sock_by_addr(u8 channel, bdaddr_t *src)
111 struct sock *sk = NULL;
113 sk_for_each(sk, &rfcomm_sk_list.head) {
114 if (rfcomm_pi(sk)->channel != channel)
117 if (bacmp(&rfcomm_pi(sk)->src, src))
120 if (sk->sk_state == BT_BOUND || sk->sk_state == BT_LISTEN)
124 return sk ? sk : NULL;
127 /* Find socket with channel and source bdaddr.
128 * Returns closest match.
130 static struct sock *rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
132 struct sock *sk = NULL, *sk1 = NULL;
134 read_lock(&rfcomm_sk_list.lock);
136 sk_for_each(sk, &rfcomm_sk_list.head) {
137 if (state && sk->sk_state != state)
140 if (rfcomm_pi(sk)->channel == channel) {
142 if (!bacmp(&rfcomm_pi(sk)->src, src))
146 if (!bacmp(&rfcomm_pi(sk)->src, BDADDR_ANY))
151 read_unlock(&rfcomm_sk_list.lock);
153 return sk ? sk : sk1;
156 static void rfcomm_sock_destruct(struct sock *sk)
158 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
160 BT_DBG("sk %p dlc %p", sk, d);
162 skb_queue_purge(&sk->sk_receive_queue);
163 skb_queue_purge(&sk->sk_write_queue);
166 rfcomm_pi(sk)->dlc = NULL;
168 /* Detach DLC if it's owned by this socket */
171 rfcomm_dlc_unlock(d);
176 static void rfcomm_sock_cleanup_listen(struct sock *parent)
180 BT_DBG("parent %p", parent);
182 /* Close not yet accepted dlcs */
183 while ((sk = bt_accept_dequeue(parent, NULL))) {
184 rfcomm_sock_close(sk);
185 rfcomm_sock_kill(sk);
188 parent->sk_state = BT_CLOSED;
189 sock_set_flag(parent, SOCK_ZAPPED);
192 /* Kill socket (only if zapped and orphan)
193 * Must be called on unlocked socket.
195 static void rfcomm_sock_kill(struct sock *sk)
197 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
200 BT_DBG("sk %p state %d refcnt %d", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
202 /* Kill poor orphan */
203 bt_sock_unlink(&rfcomm_sk_list, sk);
204 sock_set_flag(sk, SOCK_DEAD);
208 static void __rfcomm_sock_close(struct sock *sk)
210 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
212 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
214 switch (sk->sk_state) {
216 rfcomm_sock_cleanup_listen(sk);
223 rfcomm_dlc_close(d, 0);
226 sock_set_flag(sk, SOCK_ZAPPED);
232 * Must be called on unlocked socket.
234 static void rfcomm_sock_close(struct sock *sk)
237 __rfcomm_sock_close(sk);
241 static void rfcomm_sock_init(struct sock *sk, struct sock *parent)
243 struct rfcomm_pinfo *pi = rfcomm_pi(sk);
248 sk->sk_type = parent->sk_type;
249 pi->dlc->defer_setup = test_bit(BT_SK_DEFER_SETUP,
250 &bt_sk(parent)->flags);
252 pi->sec_level = rfcomm_pi(parent)->sec_level;
253 pi->role_switch = rfcomm_pi(parent)->role_switch;
255 security_sk_clone(parent, sk);
257 pi->dlc->defer_setup = 0;
259 pi->sec_level = BT_SECURITY_LOW;
263 pi->dlc->sec_level = pi->sec_level;
264 pi->dlc->role_switch = pi->role_switch;
267 static struct proto rfcomm_proto = {
269 .owner = THIS_MODULE,
270 .obj_size = sizeof(struct rfcomm_pinfo)
273 static struct sock *rfcomm_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio, int kern)
275 struct rfcomm_dlc *d;
278 sk = sk_alloc(net, PF_BLUETOOTH, prio, &rfcomm_proto, kern);
282 sock_init_data(sock, sk);
283 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
285 d = rfcomm_dlc_alloc(prio);
291 d->data_ready = rfcomm_sk_data_ready;
292 d->state_change = rfcomm_sk_state_change;
294 rfcomm_pi(sk)->dlc = d;
297 sk->sk_destruct = rfcomm_sock_destruct;
298 sk->sk_sndtimeo = RFCOMM_CONN_TIMEOUT;
300 sk->sk_sndbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
301 sk->sk_rcvbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
303 sock_reset_flag(sk, SOCK_ZAPPED);
305 sk->sk_protocol = proto;
306 sk->sk_state = BT_OPEN;
308 bt_sock_link(&rfcomm_sk_list, sk);
314 static int rfcomm_sock_create(struct net *net, struct socket *sock,
315 int protocol, int kern)
319 BT_DBG("sock %p", sock);
321 sock->state = SS_UNCONNECTED;
323 if (sock->type != SOCK_STREAM && sock->type != SOCK_RAW)
324 return -ESOCKTNOSUPPORT;
326 sock->ops = &rfcomm_sock_ops;
328 sk = rfcomm_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
332 rfcomm_sock_init(sk, NULL);
336 static int rfcomm_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
338 struct sockaddr_rc sa;
339 struct sock *sk = sock->sk;
342 if (!addr || addr->sa_family != AF_BLUETOOTH)
345 memset(&sa, 0, sizeof(sa));
346 len = min_t(unsigned int, sizeof(sa), addr_len);
347 memcpy(&sa, addr, len);
349 BT_DBG("sk %p %pMR", sk, &sa.rc_bdaddr);
353 if (sk->sk_state != BT_OPEN) {
358 if (sk->sk_type != SOCK_STREAM) {
363 write_lock(&rfcomm_sk_list.lock);
366 __rfcomm_get_listen_sock_by_addr(sa.rc_channel, &sa.rc_bdaddr)) {
369 /* Save source address */
370 bacpy(&rfcomm_pi(sk)->src, &sa.rc_bdaddr);
371 rfcomm_pi(sk)->channel = sa.rc_channel;
372 sk->sk_state = BT_BOUND;
375 write_unlock(&rfcomm_sk_list.lock);
382 static int rfcomm_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
384 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
385 struct sock *sk = sock->sk;
386 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
391 if (alen < sizeof(struct sockaddr_rc) ||
392 addr->sa_family != AF_BLUETOOTH)
397 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
402 if (sk->sk_type != SOCK_STREAM) {
407 sk->sk_state = BT_CONNECT;
408 bacpy(&rfcomm_pi(sk)->dst, &sa->rc_bdaddr);
409 rfcomm_pi(sk)->channel = sa->rc_channel;
411 d->sec_level = rfcomm_pi(sk)->sec_level;
412 d->role_switch = rfcomm_pi(sk)->role_switch;
414 err = rfcomm_dlc_open(d, &rfcomm_pi(sk)->src, &sa->rc_bdaddr,
417 err = bt_sock_wait_state(sk, BT_CONNECTED,
418 sock_sndtimeo(sk, flags & O_NONBLOCK));
425 static int rfcomm_sock_listen(struct socket *sock, int backlog)
427 struct sock *sk = sock->sk;
430 BT_DBG("sk %p backlog %d", sk, backlog);
434 if (sk->sk_state != BT_BOUND) {
439 if (sk->sk_type != SOCK_STREAM) {
444 if (!rfcomm_pi(sk)->channel) {
445 bdaddr_t *src = &rfcomm_pi(sk)->src;
450 write_lock(&rfcomm_sk_list.lock);
452 for (channel = 1; channel < 31; channel++)
453 if (!__rfcomm_get_listen_sock_by_addr(channel, src)) {
454 rfcomm_pi(sk)->channel = channel;
459 write_unlock(&rfcomm_sk_list.lock);
465 sk->sk_max_ack_backlog = backlog;
466 sk->sk_ack_backlog = 0;
467 sk->sk_state = BT_LISTEN;
474 static int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int flags)
476 DEFINE_WAIT_FUNC(wait, woken_wake_function);
477 struct sock *sk = sock->sk, *nsk;
481 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
483 if (sk->sk_type != SOCK_STREAM) {
488 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
490 BT_DBG("sk %p timeo %ld", sk, timeo);
492 /* Wait for an incoming connection. (wake-one). */
493 add_wait_queue_exclusive(sk_sleep(sk), &wait);
495 if (sk->sk_state != BT_LISTEN) {
500 nsk = bt_accept_dequeue(sk, newsock);
509 if (signal_pending(current)) {
510 err = sock_intr_errno(timeo);
516 timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, timeo);
518 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
520 remove_wait_queue(sk_sleep(sk), &wait);
525 newsock->state = SS_CONNECTED;
527 BT_DBG("new socket %p", nsk);
534 static int rfcomm_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
536 struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
537 struct sock *sk = sock->sk;
539 BT_DBG("sock %p, sk %p", sock, sk);
541 if (peer && sk->sk_state != BT_CONNECTED &&
542 sk->sk_state != BT_CONNECT && sk->sk_state != BT_CONNECT2)
545 memset(sa, 0, sizeof(*sa));
546 sa->rc_family = AF_BLUETOOTH;
547 sa->rc_channel = rfcomm_pi(sk)->channel;
549 bacpy(&sa->rc_bdaddr, &rfcomm_pi(sk)->dst);
551 bacpy(&sa->rc_bdaddr, &rfcomm_pi(sk)->src);
553 *len = sizeof(struct sockaddr_rc);
557 static int rfcomm_sock_sendmsg(struct socket *sock, struct msghdr *msg,
560 struct sock *sk = sock->sk;
561 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
565 if (test_bit(RFCOMM_DEFER_SETUP, &d->flags))
568 if (msg->msg_flags & MSG_OOB)
571 if (sk->sk_shutdown & SEND_SHUTDOWN)
574 BT_DBG("sock %p, sk %p", sock, sk);
578 sent = bt_sock_wait_ready(sk, msg->msg_flags);
583 size_t size = min_t(size_t, len, d->mtu);
586 skb = sock_alloc_send_skb(sk, size + RFCOMM_SKB_RESERVE,
587 msg->msg_flags & MSG_DONTWAIT, &err);
593 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
595 err = memcpy_from_msg(skb_put(skb, size), msg, size);
603 skb->priority = sk->sk_priority;
605 err = rfcomm_dlc_send(d, skb);
623 static int rfcomm_sock_recvmsg(struct socket *sock, struct msghdr *msg,
624 size_t size, int flags)
626 struct sock *sk = sock->sk;
627 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
630 if (test_and_clear_bit(RFCOMM_DEFER_SETUP, &d->flags)) {
631 rfcomm_dlc_accept(d);
635 len = bt_sock_stream_recvmsg(sock, msg, size, flags);
638 if (!(flags & MSG_PEEK) && len > 0)
639 atomic_sub(len, &sk->sk_rmem_alloc);
641 if (atomic_read(&sk->sk_rmem_alloc) <= (sk->sk_rcvbuf >> 2))
642 rfcomm_dlc_unthrottle(rfcomm_pi(sk)->dlc);
648 static int rfcomm_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
650 struct sock *sk = sock->sk;
660 if (get_user(opt, (u32 __user *) optval)) {
665 if (opt & RFCOMM_LM_FIPS) {
670 if (opt & RFCOMM_LM_AUTH)
671 rfcomm_pi(sk)->sec_level = BT_SECURITY_LOW;
672 if (opt & RFCOMM_LM_ENCRYPT)
673 rfcomm_pi(sk)->sec_level = BT_SECURITY_MEDIUM;
674 if (opt & RFCOMM_LM_SECURE)
675 rfcomm_pi(sk)->sec_level = BT_SECURITY_HIGH;
677 rfcomm_pi(sk)->role_switch = (opt & RFCOMM_LM_MASTER);
689 static int rfcomm_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
691 struct sock *sk = sock->sk;
692 struct bt_security sec;
699 if (level == SOL_RFCOMM)
700 return rfcomm_sock_setsockopt_old(sock, optname, optval, optlen);
702 if (level != SOL_BLUETOOTH)
709 if (sk->sk_type != SOCK_STREAM) {
714 sec.level = BT_SECURITY_LOW;
716 len = min_t(unsigned int, sizeof(sec), optlen);
717 if (copy_from_user((char *) &sec, optval, len)) {
722 if (sec.level > BT_SECURITY_HIGH) {
727 rfcomm_pi(sk)->sec_level = sec.level;
731 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
736 if (get_user(opt, (u32 __user *) optval)) {
742 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
744 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
757 static int rfcomm_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
759 struct sock *sk = sock->sk;
760 struct sock *l2cap_sk;
761 struct l2cap_conn *conn;
762 struct rfcomm_conninfo cinfo;
768 if (get_user(len, optlen))
775 switch (rfcomm_pi(sk)->sec_level) {
776 case BT_SECURITY_LOW:
777 opt = RFCOMM_LM_AUTH;
779 case BT_SECURITY_MEDIUM:
780 opt = RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT;
782 case BT_SECURITY_HIGH:
783 opt = RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT |
786 case BT_SECURITY_FIPS:
787 opt = RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT |
788 RFCOMM_LM_SECURE | RFCOMM_LM_FIPS;
795 if (rfcomm_pi(sk)->role_switch)
796 opt |= RFCOMM_LM_MASTER;
798 if (put_user(opt, (u32 __user *) optval))
803 case RFCOMM_CONNINFO:
804 if (sk->sk_state != BT_CONNECTED &&
805 !rfcomm_pi(sk)->dlc->defer_setup) {
810 l2cap_sk = rfcomm_pi(sk)->dlc->session->sock->sk;
811 conn = l2cap_pi(l2cap_sk)->chan->conn;
813 memset(&cinfo, 0, sizeof(cinfo));
814 cinfo.hci_handle = conn->hcon->handle;
815 memcpy(cinfo.dev_class, conn->hcon->dev_class, 3);
817 len = min_t(unsigned int, len, sizeof(cinfo));
818 if (copy_to_user(optval, (char *) &cinfo, len))
832 static int rfcomm_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
834 struct sock *sk = sock->sk;
835 struct bt_security sec;
840 if (level == SOL_RFCOMM)
841 return rfcomm_sock_getsockopt_old(sock, optname, optval, optlen);
843 if (level != SOL_BLUETOOTH)
846 if (get_user(len, optlen))
853 if (sk->sk_type != SOCK_STREAM) {
858 sec.level = rfcomm_pi(sk)->sec_level;
861 len = min_t(unsigned int, len, sizeof(sec));
862 if (copy_to_user(optval, (char *) &sec, len))
868 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
873 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
874 (u32 __user *) optval))
888 static int rfcomm_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
890 struct sock *sk __maybe_unused = sock->sk;
893 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
895 err = bt_sock_ioctl(sock, cmd, arg);
897 if (err == -ENOIOCTLCMD) {
898 #ifdef CONFIG_BT_RFCOMM_TTY
900 err = rfcomm_dev_ioctl(sk, cmd, (void __user *) arg);
910 static int rfcomm_sock_shutdown(struct socket *sock, int how)
912 struct sock *sk = sock->sk;
915 BT_DBG("sock %p, sk %p", sock, sk);
921 if (!sk->sk_shutdown) {
922 sk->sk_shutdown = SHUTDOWN_MASK;
923 __rfcomm_sock_close(sk);
925 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
926 !(current->flags & PF_EXITING))
927 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
933 static int rfcomm_sock_release(struct socket *sock)
935 struct sock *sk = sock->sk;
938 BT_DBG("sock %p, sk %p", sock, sk);
943 err = rfcomm_sock_shutdown(sock, 2);
946 rfcomm_sock_kill(sk);
950 /* ---- RFCOMM core layer callbacks ----
952 * called under rfcomm_lock()
954 int rfcomm_connect_ind(struct rfcomm_session *s, u8 channel, struct rfcomm_dlc **d)
956 struct sock *sk, *parent;
960 BT_DBG("session %p channel %d", s, channel);
962 rfcomm_session_getaddr(s, &src, &dst);
964 /* Check if we have socket listening on channel */
965 parent = rfcomm_get_sock_by_channel(BT_LISTEN, channel, &src);
969 bh_lock_sock(parent);
971 /* Check for backlog size */
972 if (sk_acceptq_is_full(parent)) {
973 BT_DBG("backlog full %d", parent->sk_ack_backlog);
977 sk = rfcomm_sock_alloc(sock_net(parent), NULL, BTPROTO_RFCOMM, GFP_ATOMIC, 0);
981 bt_sock_reclassify_lock(sk, BTPROTO_RFCOMM);
983 rfcomm_sock_init(sk, parent);
984 bacpy(&rfcomm_pi(sk)->src, &src);
985 bacpy(&rfcomm_pi(sk)->dst, &dst);
986 rfcomm_pi(sk)->channel = channel;
988 sk->sk_state = BT_CONFIG;
989 bt_accept_enqueue(parent, sk);
991 /* Accept connection and return socket DLC */
992 *d = rfcomm_pi(sk)->dlc;
996 bh_unlock_sock(parent);
998 if (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags))
999 parent->sk_state_change(parent);
1004 static int rfcomm_sock_debugfs_show(struct seq_file *f, void *p)
1008 read_lock(&rfcomm_sk_list.lock);
1010 sk_for_each(sk, &rfcomm_sk_list.head) {
1011 seq_printf(f, "%pMR %pMR %d %d\n",
1012 &rfcomm_pi(sk)->src, &rfcomm_pi(sk)->dst,
1013 sk->sk_state, rfcomm_pi(sk)->channel);
1016 read_unlock(&rfcomm_sk_list.lock);
1021 static int rfcomm_sock_debugfs_open(struct inode *inode, struct file *file)
1023 return single_open(file, rfcomm_sock_debugfs_show, inode->i_private);
1026 static const struct file_operations rfcomm_sock_debugfs_fops = {
1027 .open = rfcomm_sock_debugfs_open,
1029 .llseek = seq_lseek,
1030 .release = single_release,
1033 static struct dentry *rfcomm_sock_debugfs;
1035 static const struct proto_ops rfcomm_sock_ops = {
1036 .family = PF_BLUETOOTH,
1037 .owner = THIS_MODULE,
1038 .release = rfcomm_sock_release,
1039 .bind = rfcomm_sock_bind,
1040 .connect = rfcomm_sock_connect,
1041 .listen = rfcomm_sock_listen,
1042 .accept = rfcomm_sock_accept,
1043 .getname = rfcomm_sock_getname,
1044 .sendmsg = rfcomm_sock_sendmsg,
1045 .recvmsg = rfcomm_sock_recvmsg,
1046 .shutdown = rfcomm_sock_shutdown,
1047 .setsockopt = rfcomm_sock_setsockopt,
1048 .getsockopt = rfcomm_sock_getsockopt,
1049 .ioctl = rfcomm_sock_ioctl,
1050 .poll = bt_sock_poll,
1051 .socketpair = sock_no_socketpair,
1052 .mmap = sock_no_mmap
1055 static const struct net_proto_family rfcomm_sock_family_ops = {
1056 .family = PF_BLUETOOTH,
1057 .owner = THIS_MODULE,
1058 .create = rfcomm_sock_create
1061 int __init rfcomm_init_sockets(void)
1065 BUILD_BUG_ON(sizeof(struct sockaddr_rc) > sizeof(struct sockaddr));
1067 err = proto_register(&rfcomm_proto, 0);
1071 err = bt_sock_register(BTPROTO_RFCOMM, &rfcomm_sock_family_ops);
1073 BT_ERR("RFCOMM socket layer registration failed");
1077 err = bt_procfs_init(&init_net, "rfcomm", &rfcomm_sk_list, NULL);
1079 BT_ERR("Failed to create RFCOMM proc file");
1080 bt_sock_unregister(BTPROTO_RFCOMM);
1084 BT_INFO("RFCOMM socket layer initialized");
1086 if (IS_ERR_OR_NULL(bt_debugfs))
1089 rfcomm_sock_debugfs = debugfs_create_file("rfcomm", 0444,
1091 &rfcomm_sock_debugfs_fops);
1096 proto_unregister(&rfcomm_proto);
1100 void __exit rfcomm_cleanup_sockets(void)
1102 bt_procfs_cleanup(&init_net, "rfcomm");
1104 debugfs_remove(rfcomm_sock_debugfs);
1106 bt_sock_unregister(BTPROTO_RFCOMM);
1108 proto_unregister(&rfcomm_proto);