Merge branch 'linus' into x86/mm
[pandora-kernel.git] / net / bluetooth / rfcomm / sock.c
1 /*
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>
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 as
8    published by the Free Software Foundation;
9
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.
18
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.
22 */
23
24 /*
25  * RFCOMM sockets.
26  */
27
28 #include <linux/module.h>
29
30 #include <linux/types.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/sched.h>
34 #include <linux/slab.h>
35 #include <linux/poll.h>
36 #include <linux/fcntl.h>
37 #include <linux/init.h>
38 #include <linux/interrupt.h>
39 #include <linux/socket.h>
40 #include <linux/skbuff.h>
41 #include <linux/list.h>
42 #include <linux/device.h>
43 #include <net/sock.h>
44
45 #include <asm/system.h>
46 #include <asm/uaccess.h>
47
48 #include <net/bluetooth/bluetooth.h>
49 #include <net/bluetooth/hci_core.h>
50 #include <net/bluetooth/l2cap.h>
51 #include <net/bluetooth/rfcomm.h>
52
53 static const struct proto_ops rfcomm_sock_ops;
54
55 static struct bt_sock_list rfcomm_sk_list = {
56         .lock = __RW_LOCK_UNLOCKED(rfcomm_sk_list.lock)
57 };
58
59 static void rfcomm_sock_close(struct sock *sk);
60 static void rfcomm_sock_kill(struct sock *sk);
61
62 /* ---- DLC callbacks ----
63  *
64  * called under rfcomm_dlc_lock()
65  */
66 static void rfcomm_sk_data_ready(struct rfcomm_dlc *d, struct sk_buff *skb)
67 {
68         struct sock *sk = d->owner;
69         if (!sk)
70                 return;
71
72         atomic_add(skb->len, &sk->sk_rmem_alloc);
73         skb_queue_tail(&sk->sk_receive_queue, skb);
74         sk->sk_data_ready(sk, skb->len);
75
76         if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
77                 rfcomm_dlc_throttle(d);
78 }
79
80 static void rfcomm_sk_state_change(struct rfcomm_dlc *d, int err)
81 {
82         struct sock *sk = d->owner, *parent;
83         if (!sk)
84                 return;
85
86         BT_DBG("dlc %p state %ld err %d", d, d->state, err);
87
88         bh_lock_sock(sk);
89
90         if (err)
91                 sk->sk_err = err;
92
93         sk->sk_state = d->state;
94
95         parent = bt_sk(sk)->parent;
96         if (parent) {
97                 if (d->state == BT_CLOSED) {
98                         sock_set_flag(sk, SOCK_ZAPPED);
99                         bt_accept_unlink(sk);
100                 }
101                 parent->sk_data_ready(parent, 0);
102         } else {
103                 if (d->state == BT_CONNECTED)
104                         rfcomm_session_getaddr(d->session, &bt_sk(sk)->src, NULL);
105                 sk->sk_state_change(sk);
106         }
107
108         bh_unlock_sock(sk);
109
110         if (parent && sock_flag(sk, SOCK_ZAPPED)) {
111                 /* We have to drop DLC lock here, otherwise
112                  * rfcomm_sock_destruct() will dead lock. */
113                 rfcomm_dlc_unlock(d);
114                 rfcomm_sock_kill(sk);
115                 rfcomm_dlc_lock(d);
116         }
117 }
118
119 /* ---- Socket functions ---- */
120 static struct sock *__rfcomm_get_sock_by_addr(u8 channel, bdaddr_t *src)
121 {
122         struct sock *sk = NULL;
123         struct hlist_node *node;
124
125         sk_for_each(sk, node, &rfcomm_sk_list.head) {
126                 if (rfcomm_pi(sk)->channel == channel &&
127                                 !bacmp(&bt_sk(sk)->src, src))
128                         break;
129         }
130
131         return node ? sk : NULL;
132 }
133
134 /* Find socket with channel and source bdaddr.
135  * Returns closest match.
136  */
137 static struct sock *__rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
138 {
139         struct sock *sk = NULL, *sk1 = NULL;
140         struct hlist_node *node;
141
142         sk_for_each(sk, node, &rfcomm_sk_list.head) {
143                 if (state && sk->sk_state != state)
144                         continue;
145
146                 if (rfcomm_pi(sk)->channel == channel) {
147                         /* Exact match. */
148                         if (!bacmp(&bt_sk(sk)->src, src))
149                                 break;
150
151                         /* Closest match */
152                         if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
153                                 sk1 = sk;
154                 }
155         }
156         return node ? sk : sk1;
157 }
158
159 /* Find socket with given address (channel, src).
160  * Returns locked socket */
161 static inline struct sock *rfcomm_get_sock_by_channel(int state, u8 channel, bdaddr_t *src)
162 {
163         struct sock *s;
164         read_lock(&rfcomm_sk_list.lock);
165         s = __rfcomm_get_sock_by_channel(state, channel, src);
166         if (s) bh_lock_sock(s);
167         read_unlock(&rfcomm_sk_list.lock);
168         return s;
169 }
170
171 static void rfcomm_sock_destruct(struct sock *sk)
172 {
173         struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
174
175         BT_DBG("sk %p dlc %p", sk, d);
176
177         skb_queue_purge(&sk->sk_receive_queue);
178         skb_queue_purge(&sk->sk_write_queue);
179
180         rfcomm_dlc_lock(d);
181         rfcomm_pi(sk)->dlc = NULL;
182
183         /* Detach DLC if it's owned by this socket */
184         if (d->owner == sk)
185                 d->owner = NULL;
186         rfcomm_dlc_unlock(d);
187
188         rfcomm_dlc_put(d);
189 }
190
191 static void rfcomm_sock_cleanup_listen(struct sock *parent)
192 {
193         struct sock *sk;
194
195         BT_DBG("parent %p", parent);
196
197         /* Close not yet accepted dlcs */
198         while ((sk = bt_accept_dequeue(parent, NULL))) {
199                 rfcomm_sock_close(sk);
200                 rfcomm_sock_kill(sk);
201         }
202
203         parent->sk_state  = BT_CLOSED;
204         sock_set_flag(parent, SOCK_ZAPPED);
205 }
206
207 /* Kill socket (only if zapped and orphan)
208  * Must be called on unlocked socket.
209  */
210 static void rfcomm_sock_kill(struct sock *sk)
211 {
212         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
213                 return;
214
215         BT_DBG("sk %p state %d refcnt %d", sk, sk->sk_state, atomic_read(&sk->sk_refcnt));
216
217         /* Kill poor orphan */
218         bt_sock_unlink(&rfcomm_sk_list, sk);
219         sock_set_flag(sk, SOCK_DEAD);
220         sock_put(sk);
221 }
222
223 static void __rfcomm_sock_close(struct sock *sk)
224 {
225         struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
226
227         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
228
229         switch (sk->sk_state) {
230         case BT_LISTEN:
231                 rfcomm_sock_cleanup_listen(sk);
232                 break;
233
234         case BT_CONNECT:
235         case BT_CONNECT2:
236         case BT_CONFIG:
237         case BT_CONNECTED:
238                 rfcomm_dlc_close(d, 0);
239
240         default:
241                 sock_set_flag(sk, SOCK_ZAPPED);
242                 break;
243         }
244 }
245
246 /* Close socket.
247  * Must be called on unlocked socket.
248  */
249 static void rfcomm_sock_close(struct sock *sk)
250 {
251         lock_sock(sk);
252         __rfcomm_sock_close(sk);
253         release_sock(sk);
254 }
255
256 static void rfcomm_sock_init(struct sock *sk, struct sock *parent)
257 {
258         struct rfcomm_pinfo *pi = rfcomm_pi(sk);
259
260         BT_DBG("sk %p", sk);
261
262         if (parent) {
263                 sk->sk_type = parent->sk_type;
264                 pi->dlc->defer_setup = bt_sk(parent)->defer_setup;
265
266                 pi->sec_level = rfcomm_pi(parent)->sec_level;
267                 pi->role_switch = rfcomm_pi(parent)->role_switch;
268         } else {
269                 pi->dlc->defer_setup = 0;
270
271                 pi->sec_level = BT_SECURITY_LOW;
272                 pi->role_switch = 0;
273         }
274
275         pi->dlc->sec_level = pi->sec_level;
276         pi->dlc->role_switch = pi->role_switch;
277 }
278
279 static struct proto rfcomm_proto = {
280         .name           = "RFCOMM",
281         .owner          = THIS_MODULE,
282         .obj_size       = sizeof(struct rfcomm_pinfo)
283 };
284
285 static struct sock *rfcomm_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
286 {
287         struct rfcomm_dlc *d;
288         struct sock *sk;
289
290         sk = sk_alloc(net, PF_BLUETOOTH, prio, &rfcomm_proto);
291         if (!sk)
292                 return NULL;
293
294         sock_init_data(sock, sk);
295         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
296
297         d = rfcomm_dlc_alloc(prio);
298         if (!d) {
299                 sk_free(sk);
300                 return NULL;
301         }
302
303         d->data_ready   = rfcomm_sk_data_ready;
304         d->state_change = rfcomm_sk_state_change;
305
306         rfcomm_pi(sk)->dlc = d;
307         d->owner = sk;
308
309         sk->sk_destruct = rfcomm_sock_destruct;
310         sk->sk_sndtimeo = RFCOMM_CONN_TIMEOUT;
311
312         sk->sk_sndbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
313         sk->sk_rcvbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
314
315         sock_reset_flag(sk, SOCK_ZAPPED);
316
317         sk->sk_protocol = proto;
318         sk->sk_state    = BT_OPEN;
319
320         bt_sock_link(&rfcomm_sk_list, sk);
321
322         BT_DBG("sk %p", sk);
323         return sk;
324 }
325
326 static int rfcomm_sock_create(struct net *net, struct socket *sock, int protocol)
327 {
328         struct sock *sk;
329
330         BT_DBG("sock %p", sock);
331
332         sock->state = SS_UNCONNECTED;
333
334         if (sock->type != SOCK_STREAM && sock->type != SOCK_RAW)
335                 return -ESOCKTNOSUPPORT;
336
337         sock->ops = &rfcomm_sock_ops;
338
339         sk = rfcomm_sock_alloc(net, sock, protocol, GFP_ATOMIC);
340         if (!sk)
341                 return -ENOMEM;
342
343         rfcomm_sock_init(sk, NULL);
344         return 0;
345 }
346
347 static int rfcomm_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
348 {
349         struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
350         struct sock *sk = sock->sk;
351         int err = 0;
352
353         BT_DBG("sk %p %s", sk, batostr(&sa->rc_bdaddr));
354
355         if (!addr || addr->sa_family != AF_BLUETOOTH)
356                 return -EINVAL;
357
358         lock_sock(sk);
359
360         if (sk->sk_state != BT_OPEN) {
361                 err = -EBADFD;
362                 goto done;
363         }
364
365         if (sk->sk_type != SOCK_STREAM) {
366                 err = -EINVAL;
367                 goto done;
368         }
369
370         write_lock_bh(&rfcomm_sk_list.lock);
371
372         if (sa->rc_channel && __rfcomm_get_sock_by_addr(sa->rc_channel, &sa->rc_bdaddr)) {
373                 err = -EADDRINUSE;
374         } else {
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;
379         }
380
381         write_unlock_bh(&rfcomm_sk_list.lock);
382
383 done:
384         release_sock(sk);
385         return err;
386 }
387
388 static int rfcomm_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
389 {
390         struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
391         struct sock *sk = sock->sk;
392         struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
393         int err = 0;
394
395         BT_DBG("sk %p", sk);
396
397         if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_rc))
398                 return -EINVAL;
399
400         lock_sock(sk);
401
402         if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
403                 err = -EBADFD;
404                 goto done;
405         }
406
407         if (sk->sk_type != SOCK_STREAM) {
408                 err = -EINVAL;
409                 goto done;
410         }
411
412         sk->sk_state = BT_CONNECT;
413         bacpy(&bt_sk(sk)->dst, &sa->rc_bdaddr);
414         rfcomm_pi(sk)->channel = sa->rc_channel;
415
416         d->sec_level = rfcomm_pi(sk)->sec_level;
417         d->role_switch = rfcomm_pi(sk)->role_switch;
418
419         err = rfcomm_dlc_open(d, &bt_sk(sk)->src, &sa->rc_bdaddr, sa->rc_channel);
420         if (!err)
421                 err = bt_sock_wait_state(sk, BT_CONNECTED,
422                                 sock_sndtimeo(sk, flags & O_NONBLOCK));
423
424 done:
425         release_sock(sk);
426         return err;
427 }
428
429 static int rfcomm_sock_listen(struct socket *sock, int backlog)
430 {
431         struct sock *sk = sock->sk;
432         int err = 0;
433
434         BT_DBG("sk %p backlog %d", sk, backlog);
435
436         lock_sock(sk);
437
438         if (sk->sk_state != BT_BOUND) {
439                 err = -EBADFD;
440                 goto done;
441         }
442
443         if (sk->sk_type != SOCK_STREAM) {
444                 err = -EINVAL;
445                 goto done;
446         }
447
448         if (!rfcomm_pi(sk)->channel) {
449                 bdaddr_t *src = &bt_sk(sk)->src;
450                 u8 channel;
451
452                 err = -EINVAL;
453
454                 write_lock_bh(&rfcomm_sk_list.lock);
455
456                 for (channel = 1; channel < 31; channel++)
457                         if (!__rfcomm_get_sock_by_addr(channel, src)) {
458                                 rfcomm_pi(sk)->channel = channel;
459                                 err = 0;
460                                 break;
461                         }
462
463                 write_unlock_bh(&rfcomm_sk_list.lock);
464
465                 if (err < 0)
466                         goto done;
467         }
468
469         sk->sk_max_ack_backlog = backlog;
470         sk->sk_ack_backlog = 0;
471         sk->sk_state = BT_LISTEN;
472
473 done:
474         release_sock(sk);
475         return err;
476 }
477
478 static int rfcomm_sock_accept(struct socket *sock, struct socket *newsock, int flags)
479 {
480         DECLARE_WAITQUEUE(wait, current);
481         struct sock *sk = sock->sk, *nsk;
482         long timeo;
483         int err = 0;
484
485         lock_sock(sk);
486
487         if (sk->sk_state != BT_LISTEN) {
488                 err = -EBADFD;
489                 goto done;
490         }
491
492         if (sk->sk_type != SOCK_STREAM) {
493                 err = -EINVAL;
494                 goto done;
495         }
496
497         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
498
499         BT_DBG("sk %p timeo %ld", sk, timeo);
500
501         /* Wait for an incoming connection. (wake-one). */
502         add_wait_queue_exclusive(sk->sk_sleep, &wait);
503         while (!(nsk = bt_accept_dequeue(sk, newsock))) {
504                 set_current_state(TASK_INTERRUPTIBLE);
505                 if (!timeo) {
506                         err = -EAGAIN;
507                         break;
508                 }
509
510                 release_sock(sk);
511                 timeo = schedule_timeout(timeo);
512                 lock_sock(sk);
513
514                 if (sk->sk_state != BT_LISTEN) {
515                         err = -EBADFD;
516                         break;
517                 }
518
519                 if (signal_pending(current)) {
520                         err = sock_intr_errno(timeo);
521                         break;
522                 }
523         }
524         set_current_state(TASK_RUNNING);
525         remove_wait_queue(sk->sk_sleep, &wait);
526
527         if (err)
528                 goto done;
529
530         newsock->state = SS_CONNECTED;
531
532         BT_DBG("new socket %p", nsk);
533
534 done:
535         release_sock(sk);
536         return err;
537 }
538
539 static int rfcomm_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
540 {
541         struct sockaddr_rc *sa = (struct sockaddr_rc *) addr;
542         struct sock *sk = sock->sk;
543
544         BT_DBG("sock %p, sk %p", sock, sk);
545
546         sa->rc_family  = AF_BLUETOOTH;
547         sa->rc_channel = rfcomm_pi(sk)->channel;
548         if (peer)
549                 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->dst);
550         else
551                 bacpy(&sa->rc_bdaddr, &bt_sk(sk)->src);
552
553         *len = sizeof(struct sockaddr_rc);
554         return 0;
555 }
556
557 static int rfcomm_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
558                                struct msghdr *msg, size_t len)
559 {
560         struct sock *sk = sock->sk;
561         struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
562         struct sk_buff *skb;
563         int sent = 0;
564
565         if (test_bit(RFCOMM_DEFER_SETUP, &d->flags))
566                 return -ENOTCONN;
567
568         if (msg->msg_flags & MSG_OOB)
569                 return -EOPNOTSUPP;
570
571         if (sk->sk_shutdown & SEND_SHUTDOWN)
572                 return -EPIPE;
573
574         BT_DBG("sock %p, sk %p", sock, sk);
575
576         lock_sock(sk);
577
578         while (len) {
579                 size_t size = min_t(size_t, len, d->mtu);
580                 int err;
581
582                 skb = sock_alloc_send_skb(sk, size + RFCOMM_SKB_RESERVE,
583                                 msg->msg_flags & MSG_DONTWAIT, &err);
584                 if (!skb) {
585                         if (sent == 0)
586                                 sent = err;
587                         break;
588                 }
589                 skb_reserve(skb, RFCOMM_SKB_HEAD_RESERVE);
590
591                 err = memcpy_fromiovec(skb_put(skb, size), msg->msg_iov, size);
592                 if (err) {
593                         kfree_skb(skb);
594                         if (sent == 0)
595                                 sent = err;
596                         break;
597                 }
598
599                 err = rfcomm_dlc_send(d, skb);
600                 if (err < 0) {
601                         kfree_skb(skb);
602                         if (sent == 0)
603                                 sent = err;
604                         break;
605                 }
606
607                 sent += size;
608                 len  -= size;
609         }
610
611         release_sock(sk);
612
613         return sent;
614 }
615
616 static long rfcomm_sock_data_wait(struct sock *sk, long timeo)
617 {
618         DECLARE_WAITQUEUE(wait, current);
619
620         add_wait_queue(sk->sk_sleep, &wait);
621         for (;;) {
622                 set_current_state(TASK_INTERRUPTIBLE);
623
624                 if (!skb_queue_empty(&sk->sk_receive_queue) ||
625                     sk->sk_err ||
626                     (sk->sk_shutdown & RCV_SHUTDOWN) ||
627                     signal_pending(current) ||
628                     !timeo)
629                         break;
630
631                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
632                 release_sock(sk);
633                 timeo = schedule_timeout(timeo);
634                 lock_sock(sk);
635                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
636         }
637
638         __set_current_state(TASK_RUNNING);
639         remove_wait_queue(sk->sk_sleep, &wait);
640         return timeo;
641 }
642
643 static int rfcomm_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
644                                struct msghdr *msg, size_t size, int flags)
645 {
646         struct sock *sk = sock->sk;
647         struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
648         int err = 0;
649         size_t target, copied = 0;
650         long timeo;
651
652         if (test_and_clear_bit(RFCOMM_DEFER_SETUP, &d->flags)) {
653                 rfcomm_dlc_accept(d);
654                 return 0;
655         }
656
657         if (flags & MSG_OOB)
658                 return -EOPNOTSUPP;
659
660         msg->msg_namelen = 0;
661
662         BT_DBG("sk %p size %zu", sk, size);
663
664         lock_sock(sk);
665
666         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
667         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
668
669         do {
670                 struct sk_buff *skb;
671                 int chunk;
672
673                 skb = skb_dequeue(&sk->sk_receive_queue);
674                 if (!skb) {
675                         if (copied >= target)
676                                 break;
677
678                         if ((err = sock_error(sk)) != 0)
679                                 break;
680                         if (sk->sk_shutdown & RCV_SHUTDOWN)
681                                 break;
682
683                         err = -EAGAIN;
684                         if (!timeo)
685                                 break;
686
687                         timeo = rfcomm_sock_data_wait(sk, timeo);
688
689                         if (signal_pending(current)) {
690                                 err = sock_intr_errno(timeo);
691                                 goto out;
692                         }
693                         continue;
694                 }
695
696                 chunk = min_t(unsigned int, skb->len, size);
697                 if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
698                         skb_queue_head(&sk->sk_receive_queue, skb);
699                         if (!copied)
700                                 copied = -EFAULT;
701                         break;
702                 }
703                 copied += chunk;
704                 size   -= chunk;
705
706                 sock_recv_timestamp(msg, sk, skb);
707
708                 if (!(flags & MSG_PEEK)) {
709                         atomic_sub(chunk, &sk->sk_rmem_alloc);
710
711                         skb_pull(skb, chunk);
712                         if (skb->len) {
713                                 skb_queue_head(&sk->sk_receive_queue, skb);
714                                 break;
715                         }
716                         kfree_skb(skb);
717
718                 } else {
719                         /* put message back and return */
720                         skb_queue_head(&sk->sk_receive_queue, skb);
721                         break;
722                 }
723         } while (size);
724
725 out:
726         if (atomic_read(&sk->sk_rmem_alloc) <= (sk->sk_rcvbuf >> 2))
727                 rfcomm_dlc_unthrottle(rfcomm_pi(sk)->dlc);
728
729         release_sock(sk);
730         return copied ? : err;
731 }
732
733 static int rfcomm_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, int optlen)
734 {
735         struct sock *sk = sock->sk;
736         int err = 0;
737         u32 opt;
738
739         BT_DBG("sk %p", sk);
740
741         lock_sock(sk);
742
743         switch (optname) {
744         case RFCOMM_LM:
745                 if (get_user(opt, (u32 __user *) optval)) {
746                         err = -EFAULT;
747                         break;
748                 }
749
750                 if (opt & RFCOMM_LM_AUTH)
751                         rfcomm_pi(sk)->sec_level = BT_SECURITY_LOW;
752                 if (opt & RFCOMM_LM_ENCRYPT)
753                         rfcomm_pi(sk)->sec_level = BT_SECURITY_MEDIUM;
754                 if (opt & RFCOMM_LM_SECURE)
755                         rfcomm_pi(sk)->sec_level = BT_SECURITY_HIGH;
756
757                 rfcomm_pi(sk)->role_switch = (opt & RFCOMM_LM_MASTER);
758                 break;
759
760         default:
761                 err = -ENOPROTOOPT;
762                 break;
763         }
764
765         release_sock(sk);
766         return err;
767 }
768
769 static int rfcomm_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
770 {
771         struct sock *sk = sock->sk;
772         struct bt_security sec;
773         int len, err = 0;
774         u32 opt;
775
776         BT_DBG("sk %p", sk);
777
778         if (level == SOL_RFCOMM)
779                 return rfcomm_sock_setsockopt_old(sock, optname, optval, optlen);
780
781         if (level != SOL_BLUETOOTH)
782                 return -ENOPROTOOPT;
783
784         lock_sock(sk);
785
786         switch (optname) {
787         case BT_SECURITY:
788                 if (sk->sk_type != SOCK_STREAM) {
789                         err = -EINVAL;
790                         break;
791                 }
792
793                 sec.level = BT_SECURITY_LOW;
794
795                 len = min_t(unsigned int, sizeof(sec), optlen);
796                 if (copy_from_user((char *) &sec, optval, len)) {
797                         err = -EFAULT;
798                         break;
799                 }
800
801                 if (sec.level > BT_SECURITY_HIGH) {
802                         err = -EINVAL;
803                         break;
804                 }
805
806                 rfcomm_pi(sk)->sec_level = sec.level;
807                 break;
808
809         case BT_DEFER_SETUP:
810                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
811                         err = -EINVAL;
812                         break;
813                 }
814
815                 if (get_user(opt, (u32 __user *) optval)) {
816                         err = -EFAULT;
817                         break;
818                 }
819
820                 bt_sk(sk)->defer_setup = opt;
821                 break;
822
823         default:
824                 err = -ENOPROTOOPT;
825                 break;
826         }
827
828         release_sock(sk);
829         return err;
830 }
831
832 static int rfcomm_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
833 {
834         struct sock *sk = sock->sk;
835         struct sock *l2cap_sk;
836         struct rfcomm_conninfo cinfo;
837         int len, err = 0;
838         u32 opt;
839
840         BT_DBG("sk %p", sk);
841
842         if (get_user(len, optlen))
843                 return -EFAULT;
844
845         lock_sock(sk);
846
847         switch (optname) {
848         case RFCOMM_LM:
849                 switch (rfcomm_pi(sk)->sec_level) {
850                 case BT_SECURITY_LOW:
851                         opt = RFCOMM_LM_AUTH;
852                         break;
853                 case BT_SECURITY_MEDIUM:
854                         opt = RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT;
855                         break;
856                 case BT_SECURITY_HIGH:
857                         opt = RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT |
858                                                         RFCOMM_LM_SECURE;
859                         break;
860                 default:
861                         opt = 0;
862                         break;
863                 }
864
865                 if (rfcomm_pi(sk)->role_switch)
866                         opt |= RFCOMM_LM_MASTER;
867
868                 if (put_user(opt, (u32 __user *) optval))
869                         err = -EFAULT;
870                 break;
871
872         case RFCOMM_CONNINFO:
873                 if (sk->sk_state != BT_CONNECTED &&
874                                         !rfcomm_pi(sk)->dlc->defer_setup) {
875                         err = -ENOTCONN;
876                         break;
877                 }
878
879                 l2cap_sk = rfcomm_pi(sk)->dlc->session->sock->sk;
880
881                 cinfo.hci_handle = l2cap_pi(l2cap_sk)->conn->hcon->handle;
882                 memcpy(cinfo.dev_class, l2cap_pi(l2cap_sk)->conn->hcon->dev_class, 3);
883
884                 len = min_t(unsigned int, len, sizeof(cinfo));
885                 if (copy_to_user(optval, (char *) &cinfo, len))
886                         err = -EFAULT;
887
888                 break;
889
890         default:
891                 err = -ENOPROTOOPT;
892                 break;
893         }
894
895         release_sock(sk);
896         return err;
897 }
898
899 static int rfcomm_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
900 {
901         struct sock *sk = sock->sk;
902         struct bt_security sec;
903         int len, err = 0;
904
905         BT_DBG("sk %p", sk);
906
907         if (level == SOL_RFCOMM)
908                 return rfcomm_sock_getsockopt_old(sock, optname, optval, optlen);
909
910         if (level != SOL_BLUETOOTH)
911                 return -ENOPROTOOPT;
912
913         if (get_user(len, optlen))
914                 return -EFAULT;
915
916         lock_sock(sk);
917
918         switch (optname) {
919         case BT_SECURITY:
920                 if (sk->sk_type != SOCK_STREAM) {
921                         err = -EINVAL;
922                         break;
923                 }
924
925                 sec.level = rfcomm_pi(sk)->sec_level;
926
927                 len = min_t(unsigned int, len, sizeof(sec));
928                 if (copy_to_user(optval, (char *) &sec, len))
929                         err = -EFAULT;
930
931                 break;
932
933         case BT_DEFER_SETUP:
934                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
935                         err = -EINVAL;
936                         break;
937                 }
938
939                 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
940                         err = -EFAULT;
941
942                 break;
943
944         default:
945                 err = -ENOPROTOOPT;
946                 break;
947         }
948
949         release_sock(sk);
950         return err;
951 }
952
953 static int rfcomm_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
954 {
955         struct sock *sk __maybe_unused = sock->sk;
956         int err;
957
958         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
959
960         err = bt_sock_ioctl(sock, cmd, arg);
961
962         if (err == -ENOIOCTLCMD) {
963 #ifdef CONFIG_BT_RFCOMM_TTY
964                 lock_sock(sk);
965                 err = rfcomm_dev_ioctl(sk, cmd, (void __user *) arg);
966                 release_sock(sk);
967 #else
968                 err = -EOPNOTSUPP;
969 #endif
970         }
971
972         return err;
973 }
974
975 static int rfcomm_sock_shutdown(struct socket *sock, int how)
976 {
977         struct sock *sk = sock->sk;
978         int err = 0;
979
980         BT_DBG("sock %p, sk %p", sock, sk);
981
982         if (!sk) return 0;
983
984         lock_sock(sk);
985         if (!sk->sk_shutdown) {
986                 sk->sk_shutdown = SHUTDOWN_MASK;
987                 __rfcomm_sock_close(sk);
988
989                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
990                         err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
991         }
992         release_sock(sk);
993         return err;
994 }
995
996 static int rfcomm_sock_release(struct socket *sock)
997 {
998         struct sock *sk = sock->sk;
999         int err;
1000
1001         BT_DBG("sock %p, sk %p", sock, sk);
1002
1003         if (!sk)
1004                 return 0;
1005
1006         err = rfcomm_sock_shutdown(sock, 2);
1007
1008         sock_orphan(sk);
1009         rfcomm_sock_kill(sk);
1010         return err;
1011 }
1012
1013 /* ---- RFCOMM core layer callbacks ----
1014  *
1015  * called under rfcomm_lock()
1016  */
1017 int rfcomm_connect_ind(struct rfcomm_session *s, u8 channel, struct rfcomm_dlc **d)
1018 {
1019         struct sock *sk, *parent;
1020         bdaddr_t src, dst;
1021         int result = 0;
1022
1023         BT_DBG("session %p channel %d", s, channel);
1024
1025         rfcomm_session_getaddr(s, &src, &dst);
1026
1027         /* Check if we have socket listening on channel */
1028         parent = rfcomm_get_sock_by_channel(BT_LISTEN, channel, &src);
1029         if (!parent)
1030                 return 0;
1031
1032         /* Check for backlog size */
1033         if (sk_acceptq_is_full(parent)) {
1034                 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1035                 goto done;
1036         }
1037
1038         sk = rfcomm_sock_alloc(sock_net(parent), NULL, BTPROTO_RFCOMM, GFP_ATOMIC);
1039         if (!sk)
1040                 goto done;
1041
1042         rfcomm_sock_init(sk, parent);
1043         bacpy(&bt_sk(sk)->src, &src);
1044         bacpy(&bt_sk(sk)->dst, &dst);
1045         rfcomm_pi(sk)->channel = channel;
1046
1047         sk->sk_state = BT_CONFIG;
1048         bt_accept_enqueue(parent, sk);
1049
1050         /* Accept connection and return socket DLC */
1051         *d = rfcomm_pi(sk)->dlc;
1052         result = 1;
1053
1054 done:
1055         bh_unlock_sock(parent);
1056
1057         if (bt_sk(parent)->defer_setup)
1058                 parent->sk_state_change(parent);
1059
1060         return result;
1061 }
1062
1063 static ssize_t rfcomm_sock_sysfs_show(struct class *dev, char *buf)
1064 {
1065         struct sock *sk;
1066         struct hlist_node *node;
1067         char *str = buf;
1068
1069         read_lock_bh(&rfcomm_sk_list.lock);
1070
1071         sk_for_each(sk, node, &rfcomm_sk_list.head) {
1072                 str += sprintf(str, "%s %s %d %d\n",
1073                                 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
1074                                 sk->sk_state, rfcomm_pi(sk)->channel);
1075         }
1076
1077         read_unlock_bh(&rfcomm_sk_list.lock);
1078
1079         return (str - buf);
1080 }
1081
1082 static CLASS_ATTR(rfcomm, S_IRUGO, rfcomm_sock_sysfs_show, NULL);
1083
1084 static const struct proto_ops rfcomm_sock_ops = {
1085         .family         = PF_BLUETOOTH,
1086         .owner          = THIS_MODULE,
1087         .release        = rfcomm_sock_release,
1088         .bind           = rfcomm_sock_bind,
1089         .connect        = rfcomm_sock_connect,
1090         .listen         = rfcomm_sock_listen,
1091         .accept         = rfcomm_sock_accept,
1092         .getname        = rfcomm_sock_getname,
1093         .sendmsg        = rfcomm_sock_sendmsg,
1094         .recvmsg        = rfcomm_sock_recvmsg,
1095         .shutdown       = rfcomm_sock_shutdown,
1096         .setsockopt     = rfcomm_sock_setsockopt,
1097         .getsockopt     = rfcomm_sock_getsockopt,
1098         .ioctl          = rfcomm_sock_ioctl,
1099         .poll           = bt_sock_poll,
1100         .socketpair     = sock_no_socketpair,
1101         .mmap           = sock_no_mmap
1102 };
1103
1104 static struct net_proto_family rfcomm_sock_family_ops = {
1105         .family         = PF_BLUETOOTH,
1106         .owner          = THIS_MODULE,
1107         .create         = rfcomm_sock_create
1108 };
1109
1110 int __init rfcomm_init_sockets(void)
1111 {
1112         int err;
1113
1114         err = proto_register(&rfcomm_proto, 0);
1115         if (err < 0)
1116                 return err;
1117
1118         err = bt_sock_register(BTPROTO_RFCOMM, &rfcomm_sock_family_ops);
1119         if (err < 0)
1120                 goto error;
1121
1122         if (class_create_file(bt_class, &class_attr_rfcomm) < 0)
1123                 BT_ERR("Failed to create RFCOMM info file");
1124
1125         BT_INFO("RFCOMM socket layer initialized");
1126
1127         return 0;
1128
1129 error:
1130         BT_ERR("RFCOMM socket layer registration failed");
1131         proto_unregister(&rfcomm_proto);
1132         return err;
1133 }
1134
1135 void __exit rfcomm_cleanup_sockets(void)
1136 {
1137         class_remove_file(bt_class, &class_attr_rfcomm);
1138
1139         if (bt_sock_unregister(BTPROTO_RFCOMM) < 0)
1140                 BT_ERR("RFCOMM socket layer unregistration failed");
1141
1142         proto_unregister(&rfcomm_proto);
1143 }