Bluetooth: convert flushable variable to flag in l2cap chan
[linux-2.6.git] / net / bluetooth / l2cap_sock.c
1 /*
2    BlueZ - Bluetooth protocol stack for Linux
3    Copyright (C) 2000-2001 Qualcomm Incorporated
4    Copyright (C) 2009-2010 Gustavo F. Padovan <gustavo@padovan.org>
5    Copyright (C) 2010 Google Inc.
6
7    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License version 2 as
11    published by the Free Software Foundation;
12
13    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
14    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
16    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
17    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
18    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
20    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21
22    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
23    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
24    SOFTWARE IS DISCLAIMED.
25 */
26
27 /* Bluetooth L2CAP sockets. */
28
29 #include <net/bluetooth/bluetooth.h>
30 #include <net/bluetooth/hci_core.h>
31 #include <net/bluetooth/l2cap.h>
32 #include <net/bluetooth/smp.h>
33
34 static const struct proto_ops l2cap_sock_ops;
35 static void l2cap_sock_init(struct sock *sk, struct sock *parent);
36 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio);
37
38 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
39 {
40         struct sock *sk = sock->sk;
41         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
42         struct sockaddr_l2 la;
43         int len, err = 0;
44
45         BT_DBG("sk %p", sk);
46
47         if (!addr || addr->sa_family != AF_BLUETOOTH)
48                 return -EINVAL;
49
50         memset(&la, 0, sizeof(la));
51         len = min_t(unsigned int, sizeof(la), alen);
52         memcpy(&la, addr, len);
53
54         if (la.l2_cid && la.l2_psm)
55                 return -EINVAL;
56
57         lock_sock(sk);
58
59         if (sk->sk_state != BT_OPEN) {
60                 err = -EBADFD;
61                 goto done;
62         }
63
64         if (la.l2_psm) {
65                 __u16 psm = __le16_to_cpu(la.l2_psm);
66
67                 /* PSM must be odd and lsb of upper byte must be 0 */
68                 if ((psm & 0x0101) != 0x0001) {
69                         err = -EINVAL;
70                         goto done;
71                 }
72
73                 /* Restrict usage of well-known PSMs */
74                 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
75                         err = -EACCES;
76                         goto done;
77                 }
78         }
79
80         if (la.l2_cid)
81                 err = l2cap_add_scid(chan, la.l2_cid);
82         else
83                 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
84
85         if (err < 0)
86                 goto done;
87
88         if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
89                                 __le16_to_cpu(la.l2_psm) == 0x0003)
90                 chan->sec_level = BT_SECURITY_SDP;
91
92         bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
93
94         chan->state = BT_BOUND;
95         sk->sk_state = BT_BOUND;
96
97 done:
98         release_sock(sk);
99         return err;
100 }
101
102 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
103 {
104         struct sock *sk = sock->sk;
105         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
106         struct sockaddr_l2 la;
107         int len, err = 0;
108
109         BT_DBG("sk %p", sk);
110
111         if (!addr || alen < sizeof(addr->sa_family) ||
112             addr->sa_family != AF_BLUETOOTH)
113                 return -EINVAL;
114
115         memset(&la, 0, sizeof(la));
116         len = min_t(unsigned int, sizeof(la), alen);
117         memcpy(&la, addr, len);
118
119         if (la.l2_cid && la.l2_psm)
120                 return -EINVAL;
121
122         lock_sock(sk);
123
124         if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED
125                         && !(la.l2_psm || la.l2_cid)) {
126                 err = -EINVAL;
127                 goto done;
128         }
129
130         switch (chan->mode) {
131         case L2CAP_MODE_BASIC:
132                 break;
133         case L2CAP_MODE_ERTM:
134         case L2CAP_MODE_STREAMING:
135                 if (!disable_ertm)
136                         break;
137                 /* fall through */
138         default:
139                 err = -ENOTSUPP;
140                 goto done;
141         }
142
143         switch (sk->sk_state) {
144         case BT_CONNECT:
145         case BT_CONNECT2:
146         case BT_CONFIG:
147                 /* Already connecting */
148                 goto wait;
149
150         case BT_CONNECTED:
151                 /* Already connected */
152                 err = -EISCONN;
153                 goto done;
154
155         case BT_OPEN:
156         case BT_BOUND:
157                 /* Can connect */
158                 break;
159
160         default:
161                 err = -EBADFD;
162                 goto done;
163         }
164
165         /* PSM must be odd and lsb of upper byte must be 0 */
166         if ((__le16_to_cpu(la.l2_psm) & 0x0101) != 0x0001 && !la.l2_cid &&
167                                         chan->chan_type != L2CAP_CHAN_RAW) {
168                 err = -EINVAL;
169                 goto done;
170         }
171
172         /* Set destination address and psm */
173         bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
174         chan->psm = la.l2_psm;
175         chan->dcid = la.l2_cid;
176
177         err = l2cap_chan_connect(l2cap_pi(sk)->chan);
178         if (err)
179                 goto done;
180
181 wait:
182         err = bt_sock_wait_state(sk, BT_CONNECTED,
183                         sock_sndtimeo(sk, flags & O_NONBLOCK));
184 done:
185         release_sock(sk);
186         return err;
187 }
188
189 static int l2cap_sock_listen(struct socket *sock, int backlog)
190 {
191         struct sock *sk = sock->sk;
192         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
193         int err = 0;
194
195         BT_DBG("sk %p backlog %d", sk, backlog);
196
197         lock_sock(sk);
198
199         if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
200                         || sk->sk_state != BT_BOUND) {
201                 err = -EBADFD;
202                 goto done;
203         }
204
205         switch (chan->mode) {
206         case L2CAP_MODE_BASIC:
207                 break;
208         case L2CAP_MODE_ERTM:
209         case L2CAP_MODE_STREAMING:
210                 if (!disable_ertm)
211                         break;
212                 /* fall through */
213         default:
214                 err = -ENOTSUPP;
215                 goto done;
216         }
217
218         sk->sk_max_ack_backlog = backlog;
219         sk->sk_ack_backlog = 0;
220
221         chan->state = BT_LISTEN;
222         sk->sk_state = BT_LISTEN;
223
224 done:
225         release_sock(sk);
226         return err;
227 }
228
229 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
230 {
231         DECLARE_WAITQUEUE(wait, current);
232         struct sock *sk = sock->sk, *nsk;
233         long timeo;
234         int err = 0;
235
236         lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
237
238         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
239
240         BT_DBG("sk %p timeo %ld", sk, timeo);
241
242         /* Wait for an incoming connection. (wake-one). */
243         add_wait_queue_exclusive(sk_sleep(sk), &wait);
244         while (1) {
245                 set_current_state(TASK_INTERRUPTIBLE);
246
247                 if (sk->sk_state != BT_LISTEN) {
248                         err = -EBADFD;
249                         break;
250                 }
251
252                 nsk = bt_accept_dequeue(sk, newsock);
253                 if (nsk)
254                         break;
255
256                 if (!timeo) {
257                         err = -EAGAIN;
258                         break;
259                 }
260
261                 if (signal_pending(current)) {
262                         err = sock_intr_errno(timeo);
263                         break;
264                 }
265
266                 release_sock(sk);
267                 timeo = schedule_timeout(timeo);
268                 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
269         }
270         __set_current_state(TASK_RUNNING);
271         remove_wait_queue(sk_sleep(sk), &wait);
272
273         if (err)
274                 goto done;
275
276         newsock->state = SS_CONNECTED;
277
278         BT_DBG("new socket %p", nsk);
279
280 done:
281         release_sock(sk);
282         return err;
283 }
284
285 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
286 {
287         struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
288         struct sock *sk = sock->sk;
289         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
290
291         BT_DBG("sock %p, sk %p", sock, sk);
292
293         addr->sa_family = AF_BLUETOOTH;
294         *len = sizeof(struct sockaddr_l2);
295
296         if (peer) {
297                 la->l2_psm = chan->psm;
298                 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
299                 la->l2_cid = cpu_to_le16(chan->dcid);
300         } else {
301                 la->l2_psm = chan->sport;
302                 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
303                 la->l2_cid = cpu_to_le16(chan->scid);
304         }
305
306         return 0;
307 }
308
309 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
310 {
311         struct sock *sk = sock->sk;
312         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
313         struct l2cap_options opts;
314         struct l2cap_conninfo cinfo;
315         int len, err = 0;
316         u32 opt;
317
318         BT_DBG("sk %p", sk);
319
320         if (get_user(len, optlen))
321                 return -EFAULT;
322
323         lock_sock(sk);
324
325         switch (optname) {
326         case L2CAP_OPTIONS:
327                 memset(&opts, 0, sizeof(opts));
328                 opts.imtu     = chan->imtu;
329                 opts.omtu     = chan->omtu;
330                 opts.flush_to = chan->flush_to;
331                 opts.mode     = chan->mode;
332                 opts.fcs      = chan->fcs;
333                 opts.max_tx   = chan->max_tx;
334                 opts.txwin_size = (__u16)chan->tx_win;
335
336                 len = min_t(unsigned int, len, sizeof(opts));
337                 if (copy_to_user(optval, (char *) &opts, len))
338                         err = -EFAULT;
339
340                 break;
341
342         case L2CAP_LM:
343                 switch (chan->sec_level) {
344                 case BT_SECURITY_LOW:
345                         opt = L2CAP_LM_AUTH;
346                         break;
347                 case BT_SECURITY_MEDIUM:
348                         opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
349                         break;
350                 case BT_SECURITY_HIGH:
351                         opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
352                                                         L2CAP_LM_SECURE;
353                         break;
354                 default:
355                         opt = 0;
356                         break;
357                 }
358
359                 if (chan->role_switch)
360                         opt |= L2CAP_LM_MASTER;
361
362                 if (chan->force_reliable)
363                         opt |= L2CAP_LM_RELIABLE;
364
365                 if (put_user(opt, (u32 __user *) optval))
366                         err = -EFAULT;
367                 break;
368
369         case L2CAP_CONNINFO:
370                 if (sk->sk_state != BT_CONNECTED &&
371                                         !(sk->sk_state == BT_CONNECT2 &&
372                                                 bt_sk(sk)->defer_setup)) {
373                         err = -ENOTCONN;
374                         break;
375                 }
376
377                 memset(&cinfo, 0, sizeof(cinfo));
378                 cinfo.hci_handle = chan->conn->hcon->handle;
379                 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
380
381                 len = min_t(unsigned int, len, sizeof(cinfo));
382                 if (copy_to_user(optval, (char *) &cinfo, len))
383                         err = -EFAULT;
384
385                 break;
386
387         default:
388                 err = -ENOPROTOOPT;
389                 break;
390         }
391
392         release_sock(sk);
393         return err;
394 }
395
396 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
397 {
398         struct sock *sk = sock->sk;
399         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
400         struct bt_security sec;
401         struct bt_power pwr;
402         int len, err = 0;
403
404         BT_DBG("sk %p", sk);
405
406         if (level == SOL_L2CAP)
407                 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
408
409         if (level != SOL_BLUETOOTH)
410                 return -ENOPROTOOPT;
411
412         if (get_user(len, optlen))
413                 return -EFAULT;
414
415         lock_sock(sk);
416
417         switch (optname) {
418         case BT_SECURITY:
419                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
420                                         chan->chan_type != L2CAP_CHAN_RAW) {
421                         err = -EINVAL;
422                         break;
423                 }
424
425                 memset(&sec, 0, sizeof(sec));
426                 sec.level = chan->sec_level;
427
428                 if (sk->sk_state == BT_CONNECTED)
429                         sec.key_size = chan->conn->hcon->enc_key_size;
430
431                 len = min_t(unsigned int, len, sizeof(sec));
432                 if (copy_to_user(optval, (char *) &sec, len))
433                         err = -EFAULT;
434
435                 break;
436
437         case BT_DEFER_SETUP:
438                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
439                         err = -EINVAL;
440                         break;
441                 }
442
443                 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
444                         err = -EFAULT;
445
446                 break;
447
448         case BT_FLUSHABLE:
449                 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
450                                                 (u32 __user *) optval))
451                         err = -EFAULT;
452
453                 break;
454
455         case BT_POWER:
456                 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
457                                 && sk->sk_type != SOCK_RAW) {
458                         err = -EINVAL;
459                         break;
460                 }
461
462                 pwr.force_active = chan->force_active;
463
464                 len = min_t(unsigned int, len, sizeof(pwr));
465                 if (copy_to_user(optval, (char *) &pwr, len))
466                         err = -EFAULT;
467
468                 break;
469
470         default:
471                 err = -ENOPROTOOPT;
472                 break;
473         }
474
475         release_sock(sk);
476         return err;
477 }
478
479 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
480 {
481         struct sock *sk = sock->sk;
482         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
483         struct l2cap_options opts;
484         int len, err = 0;
485         u32 opt;
486
487         BT_DBG("sk %p", sk);
488
489         lock_sock(sk);
490
491         switch (optname) {
492         case L2CAP_OPTIONS:
493                 if (sk->sk_state == BT_CONNECTED) {
494                         err = -EINVAL;
495                         break;
496                 }
497
498                 opts.imtu     = chan->imtu;
499                 opts.omtu     = chan->omtu;
500                 opts.flush_to = chan->flush_to;
501                 opts.mode     = chan->mode;
502                 opts.fcs      = chan->fcs;
503                 opts.max_tx   = chan->max_tx;
504                 opts.txwin_size = (__u16)chan->tx_win;
505
506                 len = min_t(unsigned int, sizeof(opts), optlen);
507                 if (copy_from_user((char *) &opts, optval, len)) {
508                         err = -EFAULT;
509                         break;
510                 }
511
512                 if (opts.txwin_size > L2CAP_DEFAULT_TX_WINDOW) {
513                         err = -EINVAL;
514                         break;
515                 }
516
517                 chan->mode = opts.mode;
518                 switch (chan->mode) {
519                 case L2CAP_MODE_BASIC:
520                         clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
521                         break;
522                 case L2CAP_MODE_ERTM:
523                 case L2CAP_MODE_STREAMING:
524                         if (!disable_ertm)
525                                 break;
526                         /* fall through */
527                 default:
528                         err = -EINVAL;
529                         break;
530                 }
531
532                 chan->imtu = opts.imtu;
533                 chan->omtu = opts.omtu;
534                 chan->fcs  = opts.fcs;
535                 chan->max_tx = opts.max_tx;
536                 chan->tx_win = (__u8)opts.txwin_size;
537                 break;
538
539         case L2CAP_LM:
540                 if (get_user(opt, (u32 __user *) optval)) {
541                         err = -EFAULT;
542                         break;
543                 }
544
545                 if (opt & L2CAP_LM_AUTH)
546                         chan->sec_level = BT_SECURITY_LOW;
547                 if (opt & L2CAP_LM_ENCRYPT)
548                         chan->sec_level = BT_SECURITY_MEDIUM;
549                 if (opt & L2CAP_LM_SECURE)
550                         chan->sec_level = BT_SECURITY_HIGH;
551
552                 chan->role_switch    = (opt & L2CAP_LM_MASTER);
553                 chan->force_reliable = (opt & L2CAP_LM_RELIABLE);
554                 break;
555
556         default:
557                 err = -ENOPROTOOPT;
558                 break;
559         }
560
561         release_sock(sk);
562         return err;
563 }
564
565 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
566 {
567         struct sock *sk = sock->sk;
568         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
569         struct bt_security sec;
570         struct bt_power pwr;
571         struct l2cap_conn *conn;
572         int len, err = 0;
573         u32 opt;
574
575         BT_DBG("sk %p", sk);
576
577         if (level == SOL_L2CAP)
578                 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
579
580         if (level != SOL_BLUETOOTH)
581                 return -ENOPROTOOPT;
582
583         lock_sock(sk);
584
585         switch (optname) {
586         case BT_SECURITY:
587                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
588                                         chan->chan_type != L2CAP_CHAN_RAW) {
589                         err = -EINVAL;
590                         break;
591                 }
592
593                 sec.level = BT_SECURITY_LOW;
594
595                 len = min_t(unsigned int, sizeof(sec), optlen);
596                 if (copy_from_user((char *) &sec, optval, len)) {
597                         err = -EFAULT;
598                         break;
599                 }
600
601                 if (sec.level < BT_SECURITY_LOW ||
602                                         sec.level > BT_SECURITY_HIGH) {
603                         err = -EINVAL;
604                         break;
605                 }
606
607                 chan->sec_level = sec.level;
608
609                 conn = chan->conn;
610                 if (conn && chan->scid == L2CAP_CID_LE_DATA) {
611                         if (!conn->hcon->out) {
612                                 err = -EINVAL;
613                                 break;
614                         }
615
616                         if (smp_conn_security(conn, sec.level))
617                                 break;
618
619                         err = 0;
620                         sk->sk_state = BT_CONFIG;
621                 }
622                 break;
623
624         case BT_DEFER_SETUP:
625                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
626                         err = -EINVAL;
627                         break;
628                 }
629
630                 if (get_user(opt, (u32 __user *) optval)) {
631                         err = -EFAULT;
632                         break;
633                 }
634
635                 bt_sk(sk)->defer_setup = opt;
636                 break;
637
638         case BT_FLUSHABLE:
639                 if (get_user(opt, (u32 __user *) optval)) {
640                         err = -EFAULT;
641                         break;
642                 }
643
644                 if (opt > BT_FLUSHABLE_ON) {
645                         err = -EINVAL;
646                         break;
647                 }
648
649                 if (opt == BT_FLUSHABLE_OFF) {
650                         struct l2cap_conn *conn = chan->conn;
651                         /* proceed further only when we have l2cap_conn and
652                            No Flush support in the LM */
653                         if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
654                                 err = -EINVAL;
655                                 break;
656                         }
657                 }
658
659                 if (opt)
660                         set_bit(FLAG_FLUSHABLE, &chan->flags);
661                 else
662                         clear_bit(FLAG_FLUSHABLE, &chan->flags);
663                 break;
664
665         case BT_POWER:
666                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
667                                         chan->chan_type != L2CAP_CHAN_RAW) {
668                         err = -EINVAL;
669                         break;
670                 }
671
672                 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
673
674                 len = min_t(unsigned int, sizeof(pwr), optlen);
675                 if (copy_from_user((char *) &pwr, optval, len)) {
676                         err = -EFAULT;
677                         break;
678                 }
679                 chan->force_active = pwr.force_active;
680                 break;
681
682         default:
683                 err = -ENOPROTOOPT;
684                 break;
685         }
686
687         release_sock(sk);
688         return err;
689 }
690
691 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
692 {
693         struct sock *sk = sock->sk;
694         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
695         int err;
696
697         BT_DBG("sock %p, sk %p", sock, sk);
698
699         err = sock_error(sk);
700         if (err)
701                 return err;
702
703         if (msg->msg_flags & MSG_OOB)
704                 return -EOPNOTSUPP;
705
706         lock_sock(sk);
707
708         if (sk->sk_state != BT_CONNECTED) {
709                 release_sock(sk);
710                 return -ENOTCONN;
711         }
712
713         err = l2cap_chan_send(chan, msg, len);
714
715         release_sock(sk);
716         return err;
717 }
718
719 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
720 {
721         struct sock *sk = sock->sk;
722         struct l2cap_pinfo *pi = l2cap_pi(sk);
723         int err;
724
725         lock_sock(sk);
726
727         if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
728                 sk->sk_state = BT_CONFIG;
729
730                 __l2cap_connect_rsp_defer(pi->chan);
731                 release_sock(sk);
732                 return 0;
733         }
734
735         release_sock(sk);
736
737         if (sock->type == SOCK_STREAM)
738                 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
739         else
740                 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
741
742         if (pi->chan->mode != L2CAP_MODE_ERTM)
743                 return err;
744
745         /* Attempt to put pending rx data in the socket buffer */
746
747         lock_sock(sk);
748
749         if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
750                 goto done;
751
752         if (pi->rx_busy_skb) {
753                 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
754                         pi->rx_busy_skb = NULL;
755                 else
756                         goto done;
757         }
758
759         /* Restore data flow when half of the receive buffer is
760          * available.  This avoids resending large numbers of
761          * frames.
762          */
763         if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
764                 l2cap_chan_busy(pi->chan, 0);
765
766 done:
767         release_sock(sk);
768         return err;
769 }
770
771 /* Kill socket (only if zapped and orphan)
772  * Must be called on unlocked socket.
773  */
774 static void l2cap_sock_kill(struct sock *sk)
775 {
776         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
777                 return;
778
779         BT_DBG("sk %p state %d", sk, sk->sk_state);
780
781         /* Kill poor orphan */
782
783         l2cap_chan_destroy(l2cap_pi(sk)->chan);
784         sock_set_flag(sk, SOCK_DEAD);
785         sock_put(sk);
786 }
787
788 static int l2cap_sock_shutdown(struct socket *sock, int how)
789 {
790         struct sock *sk = sock->sk;
791         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
792         int err = 0;
793
794         BT_DBG("sock %p, sk %p", sock, sk);
795
796         if (!sk)
797                 return 0;
798
799         lock_sock(sk);
800         if (!sk->sk_shutdown) {
801                 if (chan->mode == L2CAP_MODE_ERTM)
802                         err = __l2cap_wait_ack(sk);
803
804                 sk->sk_shutdown = SHUTDOWN_MASK;
805                 l2cap_chan_close(chan, 0);
806
807                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
808                         err = bt_sock_wait_state(sk, BT_CLOSED,
809                                                         sk->sk_lingertime);
810         }
811
812         if (!err && sk->sk_err)
813                 err = -sk->sk_err;
814
815         release_sock(sk);
816         return err;
817 }
818
819 static int l2cap_sock_release(struct socket *sock)
820 {
821         struct sock *sk = sock->sk;
822         int err;
823
824         BT_DBG("sock %p, sk %p", sock, sk);
825
826         if (!sk)
827                 return 0;
828
829         err = l2cap_sock_shutdown(sock, 2);
830
831         sock_orphan(sk);
832         l2cap_sock_kill(sk);
833         return err;
834 }
835
836 static struct l2cap_chan *l2cap_sock_new_connection_cb(void *data)
837 {
838         struct sock *sk, *parent = data;
839
840         sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
841                                                                 GFP_ATOMIC);
842         if (!sk)
843                 return NULL;
844
845         l2cap_sock_init(sk, parent);
846
847         return l2cap_pi(sk)->chan;
848 }
849
850 static int l2cap_sock_recv_cb(void *data, struct sk_buff *skb)
851 {
852         int err;
853         struct sock *sk = data;
854         struct l2cap_pinfo *pi = l2cap_pi(sk);
855
856         if (pi->rx_busy_skb)
857                 return -ENOMEM;
858
859         err = sock_queue_rcv_skb(sk, skb);
860
861         /* For ERTM, handle one skb that doesn't fit into the recv
862          * buffer.  This is important to do because the data frames
863          * have already been acked, so the skb cannot be discarded.
864          *
865          * Notify the l2cap core that the buffer is full, so the
866          * LOCAL_BUSY state is entered and no more frames are
867          * acked and reassembled until there is buffer space
868          * available.
869          */
870         if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
871                 pi->rx_busy_skb = skb;
872                 l2cap_chan_busy(pi->chan, 1);
873                 err = 0;
874         }
875
876         return err;
877 }
878
879 static void l2cap_sock_close_cb(void *data)
880 {
881         struct sock *sk = data;
882
883         l2cap_sock_kill(sk);
884 }
885
886 static void l2cap_sock_state_change_cb(void *data, int state)
887 {
888         struct sock *sk = data;
889
890         sk->sk_state = state;
891 }
892
893 static struct l2cap_ops l2cap_chan_ops = {
894         .name           = "L2CAP Socket Interface",
895         .new_connection = l2cap_sock_new_connection_cb,
896         .recv           = l2cap_sock_recv_cb,
897         .close          = l2cap_sock_close_cb,
898         .state_change   = l2cap_sock_state_change_cb,
899 };
900
901 static void l2cap_sock_destruct(struct sock *sk)
902 {
903         BT_DBG("sk %p", sk);
904
905         if (l2cap_pi(sk)->rx_busy_skb) {
906                 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
907                 l2cap_pi(sk)->rx_busy_skb = NULL;
908         }
909
910         skb_queue_purge(&sk->sk_receive_queue);
911         skb_queue_purge(&sk->sk_write_queue);
912 }
913
914 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
915 {
916         struct l2cap_pinfo *pi = l2cap_pi(sk);
917         struct l2cap_chan *chan = pi->chan;
918
919         BT_DBG("sk %p", sk);
920
921         if (parent) {
922                 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
923
924                 sk->sk_type = parent->sk_type;
925                 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
926
927                 chan->chan_type = pchan->chan_type;
928                 chan->imtu = pchan->imtu;
929                 chan->omtu = pchan->omtu;
930                 chan->conf_state = pchan->conf_state;
931                 chan->mode = pchan->mode;
932                 chan->fcs  = pchan->fcs;
933                 chan->max_tx = pchan->max_tx;
934                 chan->tx_win = pchan->tx_win;
935                 chan->sec_level = pchan->sec_level;
936                 chan->role_switch = pchan->role_switch;
937                 chan->force_reliable = pchan->force_reliable;
938                 chan->flags = pchan->flags;
939                 chan->force_active = pchan->force_active;
940         } else {
941
942                 switch (sk->sk_type) {
943                 case SOCK_RAW:
944                         chan->chan_type = L2CAP_CHAN_RAW;
945                         break;
946                 case SOCK_DGRAM:
947                         chan->chan_type = L2CAP_CHAN_CONN_LESS;
948                         break;
949                 case SOCK_SEQPACKET:
950                 case SOCK_STREAM:
951                         chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
952                         break;
953                 }
954
955                 chan->imtu = L2CAP_DEFAULT_MTU;
956                 chan->omtu = 0;
957                 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
958                         chan->mode = L2CAP_MODE_ERTM;
959                         set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
960                 } else {
961                         chan->mode = L2CAP_MODE_BASIC;
962                 }
963                 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
964                 chan->fcs  = L2CAP_FCS_CRC16;
965                 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
966                 chan->sec_level = BT_SECURITY_LOW;
967                 chan->role_switch = 0;
968                 chan->force_reliable = 0;
969                 chan->flags = 0;
970                 chan->force_active = BT_POWER_FORCE_ACTIVE_ON;
971
972         }
973
974         /* Default config options */
975         chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
976
977         chan->data = sk;
978         chan->ops = &l2cap_chan_ops;
979 }
980
981 static struct proto l2cap_proto = {
982         .name           = "L2CAP",
983         .owner          = THIS_MODULE,
984         .obj_size       = sizeof(struct l2cap_pinfo)
985 };
986
987 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
988 {
989         struct sock *sk;
990         struct l2cap_chan *chan;
991
992         sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
993         if (!sk)
994                 return NULL;
995
996         sock_init_data(sock, sk);
997         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
998
999         sk->sk_destruct = l2cap_sock_destruct;
1000         sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1001
1002         sock_reset_flag(sk, SOCK_ZAPPED);
1003
1004         sk->sk_protocol = proto;
1005         sk->sk_state = BT_OPEN;
1006
1007         chan = l2cap_chan_create(sk);
1008         if (!chan) {
1009                 l2cap_sock_kill(sk);
1010                 return NULL;
1011         }
1012
1013         l2cap_pi(sk)->chan = chan;
1014
1015         return sk;
1016 }
1017
1018 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1019                              int kern)
1020 {
1021         struct sock *sk;
1022
1023         BT_DBG("sock %p", sock);
1024
1025         sock->state = SS_UNCONNECTED;
1026
1027         if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1028                         sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1029                 return -ESOCKTNOSUPPORT;
1030
1031         if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1032                 return -EPERM;
1033
1034         sock->ops = &l2cap_sock_ops;
1035
1036         sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1037         if (!sk)
1038                 return -ENOMEM;
1039
1040         l2cap_sock_init(sk, NULL);
1041         return 0;
1042 }
1043
1044 static const struct proto_ops l2cap_sock_ops = {
1045         .family         = PF_BLUETOOTH,
1046         .owner          = THIS_MODULE,
1047         .release        = l2cap_sock_release,
1048         .bind           = l2cap_sock_bind,
1049         .connect        = l2cap_sock_connect,
1050         .listen         = l2cap_sock_listen,
1051         .accept         = l2cap_sock_accept,
1052         .getname        = l2cap_sock_getname,
1053         .sendmsg        = l2cap_sock_sendmsg,
1054         .recvmsg        = l2cap_sock_recvmsg,
1055         .poll           = bt_sock_poll,
1056         .ioctl          = bt_sock_ioctl,
1057         .mmap           = sock_no_mmap,
1058         .socketpair     = sock_no_socketpair,
1059         .shutdown       = l2cap_sock_shutdown,
1060         .setsockopt     = l2cap_sock_setsockopt,
1061         .getsockopt     = l2cap_sock_getsockopt
1062 };
1063
1064 static const struct net_proto_family l2cap_sock_family_ops = {
1065         .family = PF_BLUETOOTH,
1066         .owner  = THIS_MODULE,
1067         .create = l2cap_sock_create,
1068 };
1069
1070 int __init l2cap_init_sockets(void)
1071 {
1072         int err;
1073
1074         err = proto_register(&l2cap_proto, 0);
1075         if (err < 0)
1076                 return err;
1077
1078         err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1079         if (err < 0)
1080                 goto error;
1081
1082         BT_INFO("L2CAP socket layer initialized");
1083
1084         return 0;
1085
1086 error:
1087         BT_ERR("L2CAP socket registration failed");
1088         proto_unregister(&l2cap_proto);
1089         return err;
1090 }
1091
1092 void l2cap_cleanup_sockets(void)
1093 {
1094         if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1095                 BT_ERR("L2CAP socket unregistration failed");
1096
1097         proto_unregister(&l2cap_proto);
1098 }