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