projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: use buffer priority to mark URB_ISO_ASAP flag
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / l2cap_sock.c
CommitLineData
bb58f747
GP		 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>
33575df7 30#include <net/bluetooth/hci_core.h>
bb58f747 31#include <net/bluetooth/l2cap.h>
f1cb9af5 32#include <net/bluetooth/smp.h>
bb58f747 33
cf2f90f5 34static const struct proto_ops l2cap_sock_ops;
80808e43
GP		 35static void l2cap_sock_init(struct sock *sk, struct sock *parent);
36static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio);
cf2f90f5 37
af6bcd82
GP		 38static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
39{
40 struct sock *sk = sock->sk;
4343478f 41 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
af6bcd82
GP		 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
b62f328b 54 if (la.l2_cid && la.l2_psm)
af6bcd82
GP		 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
9e4425ff
GP		 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);
af6bcd82 84
9e4425ff
GP		 85 if (err < 0)
86 goto done;
af6bcd82 87
9e4425ff
GP		 88 if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
89 __le16_to_cpu(la.l2_psm) == 0x0003)
90 chan->sec_level = BT_SECURITY_SDP;
b62f328b 91
9e4425ff 92 bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
89bc500e
GP		 93
94 chan->state = BT_BOUND;
9e4425ff 95 sk->sk_state = BT_BOUND;
af6bcd82
GP		 96
97done:
98 release_sock(sk);
99 return err;
100}
101
4e34c50b
GP		 102static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
103{
104 struct sock *sk = sock->sk;
0c1bc5c6 105 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
4e34c50b
GP		 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
acd7d370 119 if (la.l2_cid && la.l2_psm)
4e34c50b
GP		 120 return -EINVAL;
121
122 lock_sock(sk);
123
715ec005 124 if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED
acd7d370 125 && !(la.l2_psm || la.l2_cid)) {
4e34c50b
GP		 126 err = -EINVAL;
127 goto done;
128 }
129
0c1bc5c6 130 switch (chan->mode) {
4e34c50b
GP		 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 */
715ec005
GP		 166 if ((__le16_to_cpu(la.l2_psm) & 0x0101) != 0x0001 && !la.l2_cid &&
167 chan->chan_type != L2CAP_CHAN_RAW) {
4e34c50b
GP		 168 err = -EINVAL;
169 goto done;
170 }
171
172 /* Set destination address and psm */
173 bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
fe4128e0
GP		 174 chan->psm = la.l2_psm;
175 chan->dcid = la.l2_cid;
4e34c50b 176
77a74c7e 177 err = l2cap_chan_connect(l2cap_pi(sk)->chan);
4e34c50b
GP		 178 if (err)
179 goto done;
180
181wait:
182 err = bt_sock_wait_state(sk, BT_CONNECTED,
183 sock_sndtimeo(sk, flags & O_NONBLOCK));
184done:
185 release_sock(sk);
186 return err;
187}
188
af6bcd82
GP		 189static int l2cap_sock_listen(struct socket *sock, int backlog)
190{
191 struct sock *sk = sock->sk;
0c1bc5c6 192 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
af6bcd82
GP		 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
0c1bc5c6 205 switch (chan->mode) {
af6bcd82
GP		 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
af6bcd82
GP		 218 sk->sk_max_ack_backlog = backlog;
219 sk->sk_ack_backlog = 0;
89bc500e
GP		 220
221 chan->state = BT_LISTEN;
af6bcd82
GP		 222 sk->sk_state = BT_LISTEN;
223
224done:
225 release_sock(sk);
226 return err;
227}
228
c47b7c72
GP		 229static 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
c47b7c72
GP		 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);
f9a3c20a 244 while (1) {
c47b7c72 245 set_current_state(TASK_INTERRUPTIBLE);
f9a3c20a
PH		 246
247 if (sk->sk_state != BT_LISTEN) {
248 err = -EBADFD;
c47b7c72
GP		 249 break;
250 }
251
f9a3c20a
PH		 252 nsk = bt_accept_dequeue(sk, newsock);
253 if (nsk)
254 break;
c47b7c72 255
f9a3c20a
PH		 256 if (!timeo) {
257 err = -EAGAIN;
c47b7c72
GP		 258 break;
259 }
260
261 if (signal_pending(current)) {
262 err = sock_intr_errno(timeo);
263 break;
264 }
f9a3c20a
PH		 265
266 release_sock(sk);
267 timeo = schedule_timeout(timeo);
268 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
c47b7c72 269 }
f9a3c20a 270 __set_current_state(TASK_RUNNING);
c47b7c72
GP		 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
280done:
281 release_sock(sk);
282 return err;
283}
284
d7175d55
GP		 285static 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;
0c1bc5c6 289 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
d7175d55
GP		 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) {
fe4128e0 297 la->l2_psm = chan->psm;
d7175d55 298 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
fe4128e0 299 la->l2_cid = cpu_to_le16(chan->dcid);
d7175d55 300 } else {
0c1bc5c6 301 la->l2_psm = chan->sport;
d7175d55 302 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
fe4128e0 303 la->l2_cid = cpu_to_le16(chan->scid);
d7175d55
GP		 304 }
305
306 return 0;
307}
308
99f4808d
GP		 309static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
310{
311 struct sock *sk = sock->sk;
4343478f 312 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
99f4808d
GP		 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:
e3fb592b 327 memset(&opts, 0, sizeof(opts));
0c1bc5c6
GP		 328 opts.imtu = chan->imtu;
329 opts.omtu = chan->omtu;
330 opts.flush_to = chan->flush_to;
331 opts.mode = chan->mode;
47d1ec61
GP		 332 opts.fcs = chan->fcs;
333 opts.max_tx = chan->max_tx;
6327eb98 334 opts.txwin_size = chan->tx_win;
99f4808d
GP		 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:
4343478f 343 switch (chan->sec_level) {
99f4808d
GP		 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
43bd0f32 359 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
99f4808d
GP		 360 opt |= L2CAP_LM_MASTER;
361
ecf61bdb 362 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
99f4808d
GP		 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
8d03e971 377 memset(&cinfo, 0, sizeof(cinfo));
8c1d787b
GP		 378 cinfo.hci_handle = chan->conn->hcon->handle;
379 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
99f4808d
GP		 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
396static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
397{
398 struct sock *sk = sock->sk;
4343478f 399 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
99f4808d 400 struct bt_security sec;
14b12d0b 401 struct bt_power pwr;
99f4808d
GP		 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:
715ec005
GP		 419 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
420 chan->chan_type != L2CAP_CHAN_RAW) {
99f4808d
GP		 421 err = -EINVAL;
422 break;
423 }
424
8f360119 425 memset(&sec, 0, sizeof(sec));
4343478f 426 sec.level = chan->sec_level;
99f4808d 427
8f360119
VCG		 428 if (sk->sk_state == BT_CONNECTED)
429 sec.key_size = chan->conn->hcon->enc_key_size;
430
99f4808d
GP		 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:
d57b0e8b
AE		 449 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
450 (u32 __user *) optval))
99f4808d
GP		 451 err = -EFAULT;
452
453 break;
454
14b12d0b
JG		 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
15770b1a 462 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
14b12d0b
JG		 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
99f4808d
GP		 470 default:
471 err = -ENOPROTOOPT;
472 break;
473 }
474
475 release_sock(sk);
476 return err;
477}
478
33575df7
GP		 479static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
480{
481 struct sock *sk = sock->sk;
b4450035 482 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
33575df7
GP		 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
0c1bc5c6
GP		 498 opts.imtu = chan->imtu;
499 opts.omtu = chan->omtu;
500 opts.flush_to = chan->flush_to;
501 opts.mode = chan->mode;
47d1ec61
GP		 502 opts.fcs = chan->fcs;
503 opts.max_tx = chan->max_tx;
6327eb98 504 opts.txwin_size = chan->tx_win;
33575df7
GP		 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
6327eb98 512 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
33575df7
GP		 513 err = -EINVAL;
514 break;
515 }
516
0c1bc5c6
GP		 517 chan->mode = opts.mode;
518 switch (chan->mode) {
33575df7 519 case L2CAP_MODE_BASIC:
c1360a1c 520 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
33575df7
GP		 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
0c1bc5c6
GP		 532 chan->imtu = opts.imtu;
533 chan->omtu = opts.omtu;
47d1ec61
GP		 534 chan->fcs = opts.fcs;
535 chan->max_tx = opts.max_tx;
6327eb98 536 chan->tx_win = opts.txwin_size;
33575df7
GP		 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)
4343478f 546 chan->sec_level = BT_SECURITY_LOW;
33575df7 547 if (opt & L2CAP_LM_ENCRYPT)
4343478f 548 chan->sec_level = BT_SECURITY_MEDIUM;
33575df7 549 if (opt & L2CAP_LM_SECURE)
4343478f 550 chan->sec_level = BT_SECURITY_HIGH;
33575df7 551
43bd0f32
AE		 552 if (opt & L2CAP_LM_MASTER)
553 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
554 else
555 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
ecf61bdb
AE		 556
557 if (opt & L2CAP_LM_RELIABLE)
558 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
559 else
560 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
33575df7
GP		 561 break;
562
563 default:
564 err = -ENOPROTOOPT;
565 break;
566 }
567
568 release_sock(sk);
569 return err;
570}
571
572static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
573{
574 struct sock *sk = sock->sk;
4343478f 575 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
33575df7 576 struct bt_security sec;
14b12d0b 577 struct bt_power pwr;
f1cb9af5 578 struct l2cap_conn *conn;
33575df7
GP		 579 int len, err = 0;
580 u32 opt;
581
582 BT_DBG("sk %p", sk);
583
584 if (level == SOL_L2CAP)
585 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
586
587 if (level != SOL_BLUETOOTH)
588 return -ENOPROTOOPT;
589
590 lock_sock(sk);
591
592 switch (optname) {
593 case BT_SECURITY:
715ec005
GP		 594 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
595 chan->chan_type != L2CAP_CHAN_RAW) {
33575df7
GP		 596 err = -EINVAL;
597 break;
598 }
599
600 sec.level = BT_SECURITY_LOW;
601
602 len = min_t(unsigned int, sizeof(sec), optlen);
603 if (copy_from_user((char *) &sec, optval, len)) {
604 err = -EFAULT;
605 break;
606 }
607
608 if (sec.level < BT_SECURITY_LOW ||
609 sec.level > BT_SECURITY_HIGH) {
610 err = -EINVAL;
611 break;
612 }
613
4343478f 614 chan->sec_level = sec.level;
f1cb9af5
VCG		 615
616 conn = chan->conn;
617 if (conn && chan->scid == L2CAP_CID_LE_DATA) {
618 if (!conn->hcon->out) {
619 err = -EINVAL;
620 break;
621 }
622
623 if (smp_conn_security(conn, sec.level))
624 break;
625
626 err = 0;
627 sk->sk_state = BT_CONFIG;
628 }
33575df7
GP		 629 break;
630
631 case BT_DEFER_SETUP:
632 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
633 err = -EINVAL;
634 break;
635 }
636
637 if (get_user(opt, (u32 __user *) optval)) {
638 err = -EFAULT;
639 break;
640 }
641
642 bt_sk(sk)->defer_setup = opt;
643 break;
644
645 case BT_FLUSHABLE:
646 if (get_user(opt, (u32 __user *) optval)) {
647 err = -EFAULT;
648 break;
649 }
650
651 if (opt > BT_FLUSHABLE_ON) {
652 err = -EINVAL;
653 break;
654 }
655
656 if (opt == BT_FLUSHABLE_OFF) {
8c1d787b 657 struct l2cap_conn *conn = chan->conn;
25985edc 658 /* proceed further only when we have l2cap_conn and
33575df7
GP		 659 No Flush support in the LM */
660 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
661 err = -EINVAL;
662 break;
663 }
664 }
665
d57b0e8b
AE		 666 if (opt)
667 set_bit(FLAG_FLUSHABLE, &chan->flags);
668 else
669 clear_bit(FLAG_FLUSHABLE, &chan->flags);
33575df7
GP		 670 break;
671
14b12d0b
JG		 672 case BT_POWER:
673 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
674 chan->chan_type != L2CAP_CHAN_RAW) {
675 err = -EINVAL;
676 break;
677 }
678
679 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
680
681 len = min_t(unsigned int, sizeof(pwr), optlen);
682 if (copy_from_user((char *) &pwr, optval, len)) {
683 err = -EFAULT;
684 break;
685 }
15770b1a
AE		 686
687 if (pwr.force_active)
688 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
689 else
690 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
14b12d0b
JG		 691 break;
692
33575df7
GP		 693 default:
694 err = -ENOPROTOOPT;
695 break;
696 }
697
698 release_sock(sk);
699 return err;
700}
fd83ccdb
GP		 701
702static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
703{
704 struct sock *sk = sock->sk;
0c1bc5c6 705 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
fd83ccdb
GP		 706 int err;
707
708 BT_DBG("sock %p, sk %p", sock, sk);
709
710 err = sock_error(sk);
711 if (err)
712 return err;
713
714 if (msg->msg_flags & MSG_OOB)
715 return -EOPNOTSUPP;
716
717 lock_sock(sk);
718
719 if (sk->sk_state != BT_CONNECTED) {
9a91a04a
GP		 720 release_sock(sk);
721 return -ENOTCONN;
fd83ccdb
GP		 722 }
723
5e59b791 724 err = l2cap_chan_send(chan, msg, len, sk->sk_priority);
fd83ccdb 725
fd83ccdb
GP		 726 release_sock(sk);
727 return err;
728}
33575df7 729
68983259
GP		 730static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
731{
732 struct sock *sk = sock->sk;
e328140f
MM		 733 struct l2cap_pinfo *pi = l2cap_pi(sk);
734 int err;
68983259
GP		 735
736 lock_sock(sk);
737
738 if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
8c1d787b
GP		 739 sk->sk_state = BT_CONFIG;
740
e328140f 741 __l2cap_connect_rsp_defer(pi->chan);
68983259
GP		 742 release_sock(sk);
743 return 0;
744 }
745
746 release_sock(sk);
747
748 if (sock->type == SOCK_STREAM)
e328140f
MM		 749 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
750 else
751 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
752
753 if (pi->chan->mode != L2CAP_MODE_ERTM)
754 return err;
755
756 /* Attempt to put pending rx data in the socket buffer */
757
758 lock_sock(sk);
759
760 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
761 goto done;
762
763 if (pi->rx_busy_skb) {
764 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
765 pi->rx_busy_skb = NULL;
766 else
767 goto done;
768 }
769
770 /* Restore data flow when half of the receive buffer is
771 * available. This avoids resending large numbers of
772 * frames.
773 */
774 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
775 l2cap_chan_busy(pi->chan, 0);
68983259 776
e328140f
MM		 777done:
778 release_sock(sk);
779 return err;
68983259
GP		 780}
781
05fc1576
GP		 782/* Kill socket (only if zapped and orphan)
783 * Must be called on unlocked socket.
784 */
ba3bd0ee 785static void l2cap_sock_kill(struct sock *sk)
05fc1576
GP		 786{
787 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
788 return;
789
790 BT_DBG("sk %p state %d", sk, sk->sk_state);
791
792 /* Kill poor orphan */
6ff5abbf 793
23691d75 794 l2cap_chan_destroy(l2cap_pi(sk)->chan);
05fc1576
GP		 795 sock_set_flag(sk, SOCK_DEAD);
796 sock_put(sk);
797}
798
dcba0dba
GP		 799static int l2cap_sock_shutdown(struct socket *sock, int how)
800{
801 struct sock *sk = sock->sk;
0c1bc5c6 802 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
dcba0dba
GP		 803 int err = 0;
804
805 BT_DBG("sock %p, sk %p", sock, sk);
806
807 if (!sk)
808 return 0;
809
810 lock_sock(sk);
811 if (!sk->sk_shutdown) {
0c1bc5c6 812 if (chan->mode == L2CAP_MODE_ERTM)
dcba0dba
GP		 813 err = __l2cap_wait_ack(sk);
814
815 sk->sk_shutdown = SHUTDOWN_MASK;
0f852724 816 l2cap_chan_close(chan, 0);
dcba0dba
GP		 817
818 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
819 err = bt_sock_wait_state(sk, BT_CLOSED,
820 sk->sk_lingertime);
821 }
822
823 if (!err && sk->sk_err)
824 err = -sk->sk_err;
825
826 release_sock(sk);
827 return err;
828}
829
554f05bb
GP		 830static int l2cap_sock_release(struct socket *sock)
831{
832 struct sock *sk = sock->sk;
833 int err;
834
835 BT_DBG("sock %p, sk %p", sock, sk);
836
837 if (!sk)
838 return 0;
839
840 err = l2cap_sock_shutdown(sock, 2);
841
842 sock_orphan(sk);
843 l2cap_sock_kill(sk);
844 return err;
845}
846
80808e43
GP		 847static struct l2cap_chan *l2cap_sock_new_connection_cb(void *data)
848{
849 struct sock *sk, *parent = data;
850
851 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
852 GFP_ATOMIC);
853 if (!sk)
854 return NULL;
855
856 l2cap_sock_init(sk, parent);
857
858 return l2cap_pi(sk)->chan;
859}
860
23070494
GP		 861static int l2cap_sock_recv_cb(void *data, struct sk_buff *skb)
862{
e328140f 863 int err;
23070494 864 struct sock *sk = data;
e328140f
MM		 865 struct l2cap_pinfo *pi = l2cap_pi(sk);
866
867 if (pi->rx_busy_skb)
868 return -ENOMEM;
869
870 err = sock_queue_rcv_skb(sk, skb);
871
872 /* For ERTM, handle one skb that doesn't fit into the recv
873 * buffer. This is important to do because the data frames
874 * have already been acked, so the skb cannot be discarded.
875 *
876 * Notify the l2cap core that the buffer is full, so the
877 * LOCAL_BUSY state is entered and no more frames are
878 * acked and reassembled until there is buffer space
879 * available.
880 */
881 if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
882 pi->rx_busy_skb = skb;
883 l2cap_chan_busy(pi->chan, 1);
884 err = 0;
885 }
23070494 886
e328140f 887 return err;
23070494
GP		 888}
889
ba3bd0ee
GP		 890static void l2cap_sock_close_cb(void *data)
891{
892 struct sock *sk = data;
893
894 l2cap_sock_kill(sk);
895}
896
89bc500e
GP		 897static void l2cap_sock_state_change_cb(void *data, int state)
898{
899 struct sock *sk = data;
900
901 sk->sk_state = state;
902}
903
80808e43
GP		 904static struct l2cap_ops l2cap_chan_ops = {
905 .name = "L2CAP Socket Interface",
906 .new_connection = l2cap_sock_new_connection_cb,
23070494 907 .recv = l2cap_sock_recv_cb,
ba3bd0ee 908 .close = l2cap_sock_close_cb,
89bc500e 909 .state_change = l2cap_sock_state_change_cb,
80808e43
GP		 910};
911
bb58f747
GP		 912static void l2cap_sock_destruct(struct sock *sk)
913{
914 BT_DBG("sk %p", sk);
915
e328140f
MM		 916 if (l2cap_pi(sk)->rx_busy_skb) {
917 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
918 l2cap_pi(sk)->rx_busy_skb = NULL;
919 }
920
bb58f747
GP		 921 skb_queue_purge(&sk->sk_receive_queue);
922 skb_queue_purge(&sk->sk_write_queue);
923}
924
80808e43 925static void l2cap_sock_init(struct sock *sk, struct sock *parent)
bb58f747
GP		 926{
927 struct l2cap_pinfo *pi = l2cap_pi(sk);
b4450035 928 struct l2cap_chan *chan = pi->chan;
bb58f747
GP		 929
930 BT_DBG("sk %p", sk);
931
932 if (parent) {
b4450035
GP		 933 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
934
bb58f747
GP		 935 sk->sk_type = parent->sk_type;
936 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
937
715ec005 938 chan->chan_type = pchan->chan_type;
0c1bc5c6
GP		 939 chan->imtu = pchan->imtu;
940 chan->omtu = pchan->omtu;
b4450035 941 chan->conf_state = pchan->conf_state;
0c1bc5c6 942 chan->mode = pchan->mode;
47d1ec61
GP		 943 chan->fcs = pchan->fcs;
944 chan->max_tx = pchan->max_tx;
945 chan->tx_win = pchan->tx_win;
4343478f 946 chan->sec_level = pchan->sec_level;
d57b0e8b 947 chan->flags = pchan->flags;
bb58f747 948 } else {
715ec005
GP		 949
950 switch (sk->sk_type) {
951 case SOCK_RAW:
952 chan->chan_type = L2CAP_CHAN_RAW;
953 break;
954 case SOCK_DGRAM:
955 chan->chan_type = L2CAP_CHAN_CONN_LESS;
956 break;
957 case SOCK_SEQPACKET:
958 case SOCK_STREAM:
959 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
960 break;
961 }
962
0c1bc5c6
GP		 963 chan->imtu = L2CAP_DEFAULT_MTU;
964 chan->omtu = 0;
bb58f747 965 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
0c1bc5c6 966 chan->mode = L2CAP_MODE_ERTM;
c1360a1c 967 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
bb58f747 968 } else {
0c1bc5c6 969 chan->mode = L2CAP_MODE_BASIC;
bb58f747 970 }
47d1ec61
GP		 971 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
972 chan->fcs = L2CAP_FCS_CRC16;
973 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
4343478f 974 chan->sec_level = BT_SECURITY_LOW;
d57b0e8b 975 chan->flags = 0;
15770b1a 976 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
bb58f747
GP		 977 }
978
979 /* Default config options */
0c1bc5c6 980 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
80808e43
GP		 981
982 chan->data = sk;
983 chan->ops = &l2cap_chan_ops;
bb58f747
GP		 984}
985
986static struct proto l2cap_proto = {
987 .name = "L2CAP",
988 .owner = THIS_MODULE,
989 .obj_size = sizeof(struct l2cap_pinfo)
990};
991
80808e43 992static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
bb58f747
GP		 993{
994 struct sock *sk;
dc50a06d 995 struct l2cap_chan *chan;
bb58f747
GP		 996
997 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
998 if (!sk)
999 return NULL;
1000
1001 sock_init_data(sock, sk);
1002 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1003
1004 sk->sk_destruct = l2cap_sock_destruct;
6be6b11f 1005 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
bb58f747
GP		 1006
1007 sock_reset_flag(sk, SOCK_ZAPPED);
1008
1009 sk->sk_protocol = proto;
1010 sk->sk_state = BT_OPEN;
1011
dc50a06d
GP		 1012 chan = l2cap_chan_create(sk);
1013 if (!chan) {
1014 l2cap_sock_kill(sk);
1015 return NULL;
1016 }
1017
1018 l2cap_pi(sk)->chan = chan;
1019
bb58f747
GP		 1020 return sk;
1021}
1022
1023static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1024 int kern)
1025{
1026 struct sock *sk;
1027
1028 BT_DBG("sock %p", sock);
1029
1030 sock->state = SS_UNCONNECTED;
1031
1032 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1033 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1034 return -ESOCKTNOSUPPORT;
1035
1036 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1037 return -EPERM;
1038
1039 sock->ops = &l2cap_sock_ops;
1040
1041 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1042 if (!sk)
1043 return -ENOMEM;
1044
1045 l2cap_sock_init(sk, NULL);
1046 return 0;
1047}
1048
cf2f90f5 1049static const struct proto_ops l2cap_sock_ops = {
65390587
GP		 1050 .family = PF_BLUETOOTH,
1051 .owner = THIS_MODULE,
1052 .release = l2cap_sock_release,
1053 .bind = l2cap_sock_bind,
1054 .connect = l2cap_sock_connect,
1055 .listen = l2cap_sock_listen,
1056 .accept = l2cap_sock_accept,
1057 .getname = l2cap_sock_getname,
1058 .sendmsg = l2cap_sock_sendmsg,
1059 .recvmsg = l2cap_sock_recvmsg,
1060 .poll = bt_sock_poll,
1061 .ioctl = bt_sock_ioctl,
1062 .mmap = sock_no_mmap,
1063 .socketpair = sock_no_socketpair,
1064 .shutdown = l2cap_sock_shutdown,
1065 .setsockopt = l2cap_sock_setsockopt,
1066 .getsockopt = l2cap_sock_getsockopt
1067};
1068
bb58f747
GP		 1069static const struct net_proto_family l2cap_sock_family_ops = {
1070 .family = PF_BLUETOOTH,
1071 .owner = THIS_MODULE,
1072 .create = l2cap_sock_create,
1073};
1074
1075int __init l2cap_init_sockets(void)
1076{
e2174ca4 1077 int err;
bb58f747 1078
e2174ca4
GP		 1079 err = proto_register(&l2cap_proto, 0);
1080 if (err < 0)
1081 return err;
bb58f747 1082
e2174ca4
GP		 1083 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1084 if (err < 0)
1085 goto error;
bb58f747 1086
e2174ca4 1087 BT_INFO("L2CAP socket layer initialized");
bb58f747 1088
e2174ca4 1089 return 0;
bb58f747
GP		 1090
1091error:
e2174ca4
GP		 1092 BT_ERR("L2CAP socket registration failed");
1093 proto_unregister(&l2cap_proto);
1094 return err;
bb58f747
GP		 1095}
1096
1097void l2cap_cleanup_sockets(void)
1098{
e2174ca4
GP		 1099 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1100 BT_ERR("L2CAP socket unregistration failed");
bb58f747 1101
e2174ca4 1102 proto_unregister(&l2cap_proto);
bb58f747 1103}
kernel source for telekom puls (alcatel/mediatek)