projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Verify a pin code in pin_code_reply
[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
GP		 31#include <net/bluetooth/l2cap.h>
32
cf2f90f5
GP		 33static const struct proto_ops l2cap_sock_ops;
34
af6bcd82
GP		 35static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
36{
37 struct sock *sk = sock->sk;
4343478f 38 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
af6bcd82
GP		 39 struct sockaddr_l2 la;
40 int len, err = 0;
41
42 BT_DBG("sk %p", sk);
43
44 if (!addr || addr->sa_family != AF_BLUETOOTH)
45 return -EINVAL;
46
47 memset(&la, 0, sizeof(la));
48 len = min_t(unsigned int, sizeof(la), alen);
49 memcpy(&la, addr, len);
50
b62f328b 51 if (la.l2_cid && la.l2_psm)
af6bcd82
GP		 52 return -EINVAL;
53
54 lock_sock(sk);
55
56 if (sk->sk_state != BT_OPEN) {
57 err = -EBADFD;
58 goto done;
59 }
60
61 if (la.l2_psm) {
62 __u16 psm = __le16_to_cpu(la.l2_psm);
63
64 /* PSM must be odd and lsb of upper byte must be 0 */
65 if ((psm & 0x0101) != 0x0001) {
66 err = -EINVAL;
67 goto done;
68 }
69
70 /* Restrict usage of well-known PSMs */
71 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
72 err = -EACCES;
73 goto done;
74 }
75 }
76
9e4425ff
GP		 77 if (la.l2_cid)
78 err = l2cap_add_scid(chan, la.l2_cid);
79 else
80 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
af6bcd82 81
9e4425ff
GP		 82 if (err < 0)
83 goto done;
af6bcd82 84
9e4425ff
GP		 85 if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
86 __le16_to_cpu(la.l2_psm) == 0x0003)
87 chan->sec_level = BT_SECURITY_SDP;
b62f328b 88
9e4425ff
GP		 89 bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
90 sk->sk_state = BT_BOUND;
af6bcd82
GP		 91
92done:
93 release_sock(sk);
94 return err;
95}
96
4e34c50b
GP		 97static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
98{
99 struct sock *sk = sock->sk;
0c1bc5c6 100 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
4e34c50b
GP		 101 struct sockaddr_l2 la;
102 int len, err = 0;
103
104 BT_DBG("sk %p", sk);
105
106 if (!addr || alen < sizeof(addr->sa_family) ||
107 addr->sa_family != AF_BLUETOOTH)
108 return -EINVAL;
109
110 memset(&la, 0, sizeof(la));
111 len = min_t(unsigned int, sizeof(la), alen);
112 memcpy(&la, addr, len);
113
acd7d370 114 if (la.l2_cid && la.l2_psm)
4e34c50b
GP		 115 return -EINVAL;
116
117 lock_sock(sk);
118
715ec005 119 if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED
acd7d370 120 && !(la.l2_psm || la.l2_cid)) {
4e34c50b
GP		 121 err = -EINVAL;
122 goto done;
123 }
124
0c1bc5c6 125 switch (chan->mode) {
4e34c50b
GP		 126 case L2CAP_MODE_BASIC:
127 break;
128 case L2CAP_MODE_ERTM:
129 case L2CAP_MODE_STREAMING:
130 if (!disable_ertm)
131 break;
132 /* fall through */
133 default:
134 err = -ENOTSUPP;
135 goto done;
136 }
137
138 switch (sk->sk_state) {
139 case BT_CONNECT:
140 case BT_CONNECT2:
141 case BT_CONFIG:
142 /* Already connecting */
143 goto wait;
144
145 case BT_CONNECTED:
146 /* Already connected */
147 err = -EISCONN;
148 goto done;
149
150 case BT_OPEN:
151 case BT_BOUND:
152 /* Can connect */
153 break;
154
155 default:
156 err = -EBADFD;
157 goto done;
158 }
159
160 /* PSM must be odd and lsb of upper byte must be 0 */
715ec005
GP		 161 if ((__le16_to_cpu(la.l2_psm) & 0x0101) != 0x0001 && !la.l2_cid &&
162 chan->chan_type != L2CAP_CHAN_RAW) {
4e34c50b
GP		 163 err = -EINVAL;
164 goto done;
165 }
166
167 /* Set destination address and psm */
168 bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
fe4128e0
GP		 169 chan->psm = la.l2_psm;
170 chan->dcid = la.l2_cid;
4e34c50b 171
77a74c7e 172 err = l2cap_chan_connect(l2cap_pi(sk)->chan);
4e34c50b
GP		 173 if (err)
174 goto done;
175
176wait:
177 err = bt_sock_wait_state(sk, BT_CONNECTED,
178 sock_sndtimeo(sk, flags & O_NONBLOCK));
179done:
180 release_sock(sk);
181 return err;
182}
183
af6bcd82
GP		 184static int l2cap_sock_listen(struct socket *sock, int backlog)
185{
186 struct sock *sk = sock->sk;
0c1bc5c6 187 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
af6bcd82
GP		 188 int err = 0;
189
190 BT_DBG("sk %p backlog %d", sk, backlog);
191
192 lock_sock(sk);
193
194 if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
195 || sk->sk_state != BT_BOUND) {
196 err = -EBADFD;
197 goto done;
198 }
199
0c1bc5c6 200 switch (chan->mode) {
af6bcd82
GP		 201 case L2CAP_MODE_BASIC:
202 break;
203 case L2CAP_MODE_ERTM:
204 case L2CAP_MODE_STREAMING:
205 if (!disable_ertm)
206 break;
207 /* fall through */
208 default:
209 err = -ENOTSUPP;
210 goto done;
211 }
212
af6bcd82
GP		 213 sk->sk_max_ack_backlog = backlog;
214 sk->sk_ack_backlog = 0;
215 sk->sk_state = BT_LISTEN;
216
217done:
218 release_sock(sk);
219 return err;
220}
221
c47b7c72
GP		 222static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
223{
224 DECLARE_WAITQUEUE(wait, current);
225 struct sock *sk = sock->sk, *nsk;
226 long timeo;
227 int err = 0;
228
229 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
230
231 if (sk->sk_state != BT_LISTEN) {
232 err = -EBADFD;
233 goto done;
234 }
235
236 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
237
238 BT_DBG("sk %p timeo %ld", sk, timeo);
239
240 /* Wait for an incoming connection. (wake-one). */
241 add_wait_queue_exclusive(sk_sleep(sk), &wait);
242 while (!(nsk = bt_accept_dequeue(sk, newsock))) {
243 set_current_state(TASK_INTERRUPTIBLE);
244 if (!timeo) {
245 err = -EAGAIN;
246 break;
247 }
248
249 release_sock(sk);
250 timeo = schedule_timeout(timeo);
251 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
252
253 if (sk->sk_state != BT_LISTEN) {
254 err = -EBADFD;
255 break;
256 }
257
258 if (signal_pending(current)) {
259 err = sock_intr_errno(timeo);
260 break;
261 }
262 }
263 set_current_state(TASK_RUNNING);
264 remove_wait_queue(sk_sleep(sk), &wait);
265
266 if (err)
267 goto done;
268
269 newsock->state = SS_CONNECTED;
270
271 BT_DBG("new socket %p", nsk);
272
273done:
274 release_sock(sk);
275 return err;
276}
277
d7175d55
GP		 278static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
279{
280 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
281 struct sock *sk = sock->sk;
0c1bc5c6 282 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
d7175d55
GP		 283
284 BT_DBG("sock %p, sk %p", sock, sk);
285
286 addr->sa_family = AF_BLUETOOTH;
287 *len = sizeof(struct sockaddr_l2);
288
289 if (peer) {
fe4128e0 290 la->l2_psm = chan->psm;
d7175d55 291 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
fe4128e0 292 la->l2_cid = cpu_to_le16(chan->dcid);
d7175d55 293 } else {
0c1bc5c6 294 la->l2_psm = chan->sport;
d7175d55 295 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
fe4128e0 296 la->l2_cid = cpu_to_le16(chan->scid);
d7175d55
GP		 297 }
298
299 return 0;
300}
301
99f4808d
GP		 302static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
303{
304 struct sock *sk = sock->sk;
4343478f 305 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
99f4808d
GP		 306 struct l2cap_options opts;
307 struct l2cap_conninfo cinfo;
308 int len, err = 0;
309 u32 opt;
310
311 BT_DBG("sk %p", sk);
312
313 if (get_user(len, optlen))
314 return -EFAULT;
315
316 lock_sock(sk);
317
318 switch (optname) {
319 case L2CAP_OPTIONS:
e3fb592b 320 memset(&opts, 0, sizeof(opts));
0c1bc5c6
GP		 321 opts.imtu = chan->imtu;
322 opts.omtu = chan->omtu;
323 opts.flush_to = chan->flush_to;
324 opts.mode = chan->mode;
47d1ec61
GP		 325 opts.fcs = chan->fcs;
326 opts.max_tx = chan->max_tx;
327 opts.txwin_size = (__u16)chan->tx_win;
99f4808d
GP		 328
329 len = min_t(unsigned int, len, sizeof(opts));
330 if (copy_to_user(optval, (char *) &opts, len))
331 err = -EFAULT;
332
333 break;
334
335 case L2CAP_LM:
4343478f 336 switch (chan->sec_level) {
99f4808d
GP		 337 case BT_SECURITY_LOW:
338 opt = L2CAP_LM_AUTH;
339 break;
340 case BT_SECURITY_MEDIUM:
341 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
342 break;
343 case BT_SECURITY_HIGH:
344 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
345 L2CAP_LM_SECURE;
346 break;
347 default:
348 opt = 0;
349 break;
350 }
351
4343478f 352 if (chan->role_switch)
99f4808d
GP		 353 opt |= L2CAP_LM_MASTER;
354
4343478f 355 if (chan->force_reliable)
99f4808d
GP		 356 opt |= L2CAP_LM_RELIABLE;
357
358 if (put_user(opt, (u32 __user *) optval))
359 err = -EFAULT;
360 break;
361
362 case L2CAP_CONNINFO:
363 if (sk->sk_state != BT_CONNECTED &&
364 !(sk->sk_state == BT_CONNECT2 &&
365 bt_sk(sk)->defer_setup)) {
366 err = -ENOTCONN;
367 break;
368 }
369
8c1d787b
GP		 370 cinfo.hci_handle = chan->conn->hcon->handle;
371 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
99f4808d
GP		 372
373 len = min_t(unsigned int, len, sizeof(cinfo));
374 if (copy_to_user(optval, (char *) &cinfo, len))
375 err = -EFAULT;
376
377 break;
378
379 default:
380 err = -ENOPROTOOPT;
381 break;
382 }
383
384 release_sock(sk);
385 return err;
386}
387
388static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
389{
390 struct sock *sk = sock->sk;
4343478f 391 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
99f4808d
GP		 392 struct bt_security sec;
393 int len, err = 0;
394
395 BT_DBG("sk %p", sk);
396
397 if (level == SOL_L2CAP)
398 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
399
400 if (level != SOL_BLUETOOTH)
401 return -ENOPROTOOPT;
402
403 if (get_user(len, optlen))
404 return -EFAULT;
405
406 lock_sock(sk);
407
408 switch (optname) {
409 case BT_SECURITY:
715ec005
GP		 410 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
411 chan->chan_type != L2CAP_CHAN_RAW) {
99f4808d
GP		 412 err = -EINVAL;
413 break;
414 }
415
4343478f 416 sec.level = chan->sec_level;
99f4808d
GP		 417
418 len = min_t(unsigned int, len, sizeof(sec));
419 if (copy_to_user(optval, (char *) &sec, len))
420 err = -EFAULT;
421
422 break;
423
424 case BT_DEFER_SETUP:
425 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
426 err = -EINVAL;
427 break;
428 }
429
430 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
431 err = -EFAULT;
432
433 break;
434
435 case BT_FLUSHABLE:
4343478f 436 if (put_user(chan->flushable, (u32 __user *) optval))
99f4808d
GP		 437 err = -EFAULT;
438
439 break;
440
441 default:
442 err = -ENOPROTOOPT;
443 break;
444 }
445
446 release_sock(sk);
447 return err;
448}
449
33575df7
GP		 450static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
451{
452 struct sock *sk = sock->sk;
b4450035 453 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
33575df7
GP		 454 struct l2cap_options opts;
455 int len, err = 0;
456 u32 opt;
457
458 BT_DBG("sk %p", sk);
459
460 lock_sock(sk);
461
462 switch (optname) {
463 case L2CAP_OPTIONS:
464 if (sk->sk_state == BT_CONNECTED) {
465 err = -EINVAL;
466 break;
467 }
468
0c1bc5c6
GP		 469 opts.imtu = chan->imtu;
470 opts.omtu = chan->omtu;
471 opts.flush_to = chan->flush_to;
472 opts.mode = chan->mode;
47d1ec61
GP		 473 opts.fcs = chan->fcs;
474 opts.max_tx = chan->max_tx;
475 opts.txwin_size = (__u16)chan->tx_win;
33575df7
GP		 476
477 len = min_t(unsigned int, sizeof(opts), optlen);
478 if (copy_from_user((char *) &opts, optval, len)) {
479 err = -EFAULT;
480 break;
481 }
482
483 if (opts.txwin_size > L2CAP_DEFAULT_TX_WINDOW) {
484 err = -EINVAL;
485 break;
486 }
487
0c1bc5c6
GP		 488 chan->mode = opts.mode;
489 switch (chan->mode) {
33575df7 490 case L2CAP_MODE_BASIC:
b4450035 491 chan->conf_state &= ~L2CAP_CONF_STATE2_DEVICE;
33575df7
GP		 492 break;
493 case L2CAP_MODE_ERTM:
494 case L2CAP_MODE_STREAMING:
495 if (!disable_ertm)
496 break;
497 /* fall through */
498 default:
499 err = -EINVAL;
500 break;
501 }
502
0c1bc5c6
GP		 503 chan->imtu = opts.imtu;
504 chan->omtu = opts.omtu;
47d1ec61
GP		 505 chan->fcs = opts.fcs;
506 chan->max_tx = opts.max_tx;
507 chan->tx_win = (__u8)opts.txwin_size;
33575df7
GP		 508 break;
509
510 case L2CAP_LM:
511 if (get_user(opt, (u32 __user *) optval)) {
512 err = -EFAULT;
513 break;
514 }
515
516 if (opt & L2CAP_LM_AUTH)
4343478f 517 chan->sec_level = BT_SECURITY_LOW;
33575df7 518 if (opt & L2CAP_LM_ENCRYPT)
4343478f 519 chan->sec_level = BT_SECURITY_MEDIUM;
33575df7 520 if (opt & L2CAP_LM_SECURE)
4343478f 521 chan->sec_level = BT_SECURITY_HIGH;
33575df7 522
4343478f
GP		 523 chan->role_switch = (opt & L2CAP_LM_MASTER);
524 chan->force_reliable = (opt & L2CAP_LM_RELIABLE);
33575df7
GP		 525 break;
526
527 default:
528 err = -ENOPROTOOPT;
529 break;
530 }
531
532 release_sock(sk);
533 return err;
534}
535
536static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
537{
538 struct sock *sk = sock->sk;
4343478f 539 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
33575df7
GP		 540 struct bt_security sec;
541 int len, err = 0;
542 u32 opt;
543
544 BT_DBG("sk %p", sk);
545
546 if (level == SOL_L2CAP)
547 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
548
549 if (level != SOL_BLUETOOTH)
550 return -ENOPROTOOPT;
551
552 lock_sock(sk);
553
554 switch (optname) {
555 case BT_SECURITY:
715ec005
GP		 556 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
557 chan->chan_type != L2CAP_CHAN_RAW) {
33575df7
GP		 558 err = -EINVAL;
559 break;
560 }
561
562 sec.level = BT_SECURITY_LOW;
563
564 len = min_t(unsigned int, sizeof(sec), optlen);
565 if (copy_from_user((char *) &sec, optval, len)) {
566 err = -EFAULT;
567 break;
568 }
569
570 if (sec.level < BT_SECURITY_LOW ||
571 sec.level > BT_SECURITY_HIGH) {
572 err = -EINVAL;
573 break;
574 }
575
4343478f 576 chan->sec_level = sec.level;
33575df7
GP		 577 break;
578
579 case BT_DEFER_SETUP:
580 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
581 err = -EINVAL;
582 break;
583 }
584
585 if (get_user(opt, (u32 __user *) optval)) {
586 err = -EFAULT;
587 break;
588 }
589
590 bt_sk(sk)->defer_setup = opt;
591 break;
592
593 case BT_FLUSHABLE:
594 if (get_user(opt, (u32 __user *) optval)) {
595 err = -EFAULT;
596 break;
597 }
598
599 if (opt > BT_FLUSHABLE_ON) {
600 err = -EINVAL;
601 break;
602 }
603
604 if (opt == BT_FLUSHABLE_OFF) {
8c1d787b 605 struct l2cap_conn *conn = chan->conn;
25985edc 606 /* proceed further only when we have l2cap_conn and
33575df7
GP		 607 No Flush support in the LM */
608 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
609 err = -EINVAL;
610 break;
611 }
612 }
613
4343478f 614 chan->flushable = opt;
33575df7
GP		 615 break;
616
617 default:
618 err = -ENOPROTOOPT;
619 break;
620 }
621
622 release_sock(sk);
623 return err;
624}
fd83ccdb
GP		 625
626static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
627{
628 struct sock *sk = sock->sk;
0c1bc5c6 629 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
fd83ccdb
GP		 630 int err;
631
632 BT_DBG("sock %p, sk %p", sock, sk);
633
634 err = sock_error(sk);
635 if (err)
636 return err;
637
638 if (msg->msg_flags & MSG_OOB)
639 return -EOPNOTSUPP;
640
641 lock_sock(sk);
642
643 if (sk->sk_state != BT_CONNECTED) {
9a91a04a
GP		 644 release_sock(sk);
645 return -ENOTCONN;
fd83ccdb
GP		 646 }
647
9a91a04a 648 err = l2cap_chan_send(chan, msg, len);
fd83ccdb 649
fd83ccdb
GP		 650 release_sock(sk);
651 return err;
652}
33575df7 653
68983259
GP		 654static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
655{
656 struct sock *sk = sock->sk;
657
658 lock_sock(sk);
659
660 if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
8c1d787b
GP		 661 sk->sk_state = BT_CONFIG;
662
663 __l2cap_connect_rsp_defer(l2cap_pi(sk)->chan);
68983259
GP		 664 release_sock(sk);
665 return 0;
666 }
667
668 release_sock(sk);
669
670 if (sock->type == SOCK_STREAM)
671 return bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
672
673 return bt_sock_recvmsg(iocb, sock, msg, len, flags);
674}
675
05fc1576
GP		 676/* Kill socket (only if zapped and orphan)
677 * Must be called on unlocked socket.
678 */
679void l2cap_sock_kill(struct sock *sk)
680{
681 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
682 return;
683
684 BT_DBG("sk %p state %d", sk, sk->sk_state);
685
686 /* Kill poor orphan */
6ff5abbf 687
23691d75 688 l2cap_chan_destroy(l2cap_pi(sk)->chan);
05fc1576
GP		 689 sock_set_flag(sk, SOCK_DEAD);
690 sock_put(sk);
691}
692
dcba0dba
GP		 693static int l2cap_sock_shutdown(struct socket *sock, int how)
694{
695 struct sock *sk = sock->sk;
0c1bc5c6 696 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
dcba0dba
GP		 697 int err = 0;
698
699 BT_DBG("sock %p, sk %p", sock, sk);
700
701 if (!sk)
702 return 0;
703
704 lock_sock(sk);
705 if (!sk->sk_shutdown) {
0c1bc5c6 706 if (chan->mode == L2CAP_MODE_ERTM)
dcba0dba
GP		 707 err = __l2cap_wait_ack(sk);
708
709 sk->sk_shutdown = SHUTDOWN_MASK;
0f852724 710 l2cap_chan_close(chan, 0);
dcba0dba
GP		 711
712 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
713 err = bt_sock_wait_state(sk, BT_CLOSED,
714 sk->sk_lingertime);
715 }
716
717 if (!err && sk->sk_err)
718 err = -sk->sk_err;
719
720 release_sock(sk);
721 return err;
722}
723
554f05bb
GP		 724static int l2cap_sock_release(struct socket *sock)
725{
726 struct sock *sk = sock->sk;
727 int err;
728
729 BT_DBG("sock %p, sk %p", sock, sk);
730
731 if (!sk)
732 return 0;
733
734 err = l2cap_sock_shutdown(sock, 2);
735
736 sock_orphan(sk);
737 l2cap_sock_kill(sk);
738 return err;
739}
740
bb58f747
GP		 741static void l2cap_sock_destruct(struct sock *sk)
742{
743 BT_DBG("sk %p", sk);
744
745 skb_queue_purge(&sk->sk_receive_queue);
746 skb_queue_purge(&sk->sk_write_queue);
747}
748
749void l2cap_sock_init(struct sock *sk, struct sock *parent)
750{
751 struct l2cap_pinfo *pi = l2cap_pi(sk);
b4450035 752 struct l2cap_chan *chan = pi->chan;
bb58f747
GP		 753
754 BT_DBG("sk %p", sk);
755
756 if (parent) {
b4450035
GP		 757 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
758
bb58f747
GP		 759 sk->sk_type = parent->sk_type;
760 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
761
715ec005 762 chan->chan_type = pchan->chan_type;
0c1bc5c6
GP		 763 chan->imtu = pchan->imtu;
764 chan->omtu = pchan->omtu;
b4450035 765 chan->conf_state = pchan->conf_state;
0c1bc5c6 766 chan->mode = pchan->mode;
47d1ec61
GP		 767 chan->fcs = pchan->fcs;
768 chan->max_tx = pchan->max_tx;
769 chan->tx_win = pchan->tx_win;
4343478f
GP		 770 chan->sec_level = pchan->sec_level;
771 chan->role_switch = pchan->role_switch;
772 chan->force_reliable = pchan->force_reliable;
773 chan->flushable = pchan->flushable;
bb58f747 774 } else {
715ec005
GP		 775
776 switch (sk->sk_type) {
777 case SOCK_RAW:
778 chan->chan_type = L2CAP_CHAN_RAW;
779 break;
780 case SOCK_DGRAM:
781 chan->chan_type = L2CAP_CHAN_CONN_LESS;
782 break;
783 case SOCK_SEQPACKET:
784 case SOCK_STREAM:
785 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
786 break;
787 }
788
0c1bc5c6
GP		 789 chan->imtu = L2CAP_DEFAULT_MTU;
790 chan->omtu = 0;
bb58f747 791 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
0c1bc5c6 792 chan->mode = L2CAP_MODE_ERTM;
b4450035 793 chan->conf_state |= L2CAP_CONF_STATE2_DEVICE;
bb58f747 794 } else {
0c1bc5c6 795 chan->mode = L2CAP_MODE_BASIC;
bb58f747 796 }
47d1ec61
GP		 797 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
798 chan->fcs = L2CAP_FCS_CRC16;
799 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
4343478f
GP		 800 chan->sec_level = BT_SECURITY_LOW;
801 chan->role_switch = 0;
802 chan->force_reliable = 0;
803 chan->flushable = BT_FLUSHABLE_OFF;
bb58f747
GP		 804 }
805
806 /* Default config options */
0c1bc5c6 807 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
bb58f747
GP		 808}
809
810static struct proto l2cap_proto = {
811 .name = "L2CAP",
812 .owner = THIS_MODULE,
813 .obj_size = sizeof(struct l2cap_pinfo)
814};
815
816struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
817{
818 struct sock *sk;
819
820 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
821 if (!sk)
822 return NULL;
823
824 sock_init_data(sock, sk);
825 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
826
827 sk->sk_destruct = l2cap_sock_destruct;
828 sk->sk_sndtimeo = msecs_to_jiffies(L2CAP_CONN_TIMEOUT);
829
830 sock_reset_flag(sk, SOCK_ZAPPED);
831
832 sk->sk_protocol = proto;
833 sk->sk_state = BT_OPEN;
834
bb58f747
GP		 835 return sk;
836}
837
838static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
839 int kern)
840{
841 struct sock *sk;
5d41ce1d 842 struct l2cap_chan *chan;
bb58f747
GP		 843
844 BT_DBG("sock %p", sock);
845
846 sock->state = SS_UNCONNECTED;
847
848 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
849 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
850 return -ESOCKTNOSUPPORT;
851
852 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
853 return -EPERM;
854
855 sock->ops = &l2cap_sock_ops;
856
857 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
858 if (!sk)
859 return -ENOMEM;
860
23691d75 861 chan = l2cap_chan_create(sk);
5d41ce1d
GP		 862 if (!chan) {
863 l2cap_sock_kill(sk);
864 return -ENOMEM;
865 }
866
867 l2cap_pi(sk)->chan = chan;
868
bb58f747
GP		 869 l2cap_sock_init(sk, NULL);
870 return 0;
871}
872
cf2f90f5 873static const struct proto_ops l2cap_sock_ops = {
65390587
GP		 874 .family = PF_BLUETOOTH,
875 .owner = THIS_MODULE,
876 .release = l2cap_sock_release,
877 .bind = l2cap_sock_bind,
878 .connect = l2cap_sock_connect,
879 .listen = l2cap_sock_listen,
880 .accept = l2cap_sock_accept,
881 .getname = l2cap_sock_getname,
882 .sendmsg = l2cap_sock_sendmsg,
883 .recvmsg = l2cap_sock_recvmsg,
884 .poll = bt_sock_poll,
885 .ioctl = bt_sock_ioctl,
886 .mmap = sock_no_mmap,
887 .socketpair = sock_no_socketpair,
888 .shutdown = l2cap_sock_shutdown,
889 .setsockopt = l2cap_sock_setsockopt,
890 .getsockopt = l2cap_sock_getsockopt
891};
892
bb58f747
GP		 893static const struct net_proto_family l2cap_sock_family_ops = {
894 .family = PF_BLUETOOTH,
895 .owner = THIS_MODULE,
896 .create = l2cap_sock_create,
897};
898
899int __init l2cap_init_sockets(void)
900{
e2174ca4 901 int err;
bb58f747 902
e2174ca4
GP		 903 err = proto_register(&l2cap_proto, 0);
904 if (err < 0)
905 return err;
bb58f747 906
e2174ca4
GP		 907 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
908 if (err < 0)
909 goto error;
bb58f747 910
e2174ca4 911 BT_INFO("L2CAP socket layer initialized");
bb58f747 912
e2174ca4 913 return 0;
bb58f747
GP		 914
915error:
e2174ca4
GP		 916 BT_ERR("L2CAP socket registration failed");
917 proto_unregister(&l2cap_proto);
918 return err;
bb58f747
GP		 919}
920
921void l2cap_cleanup_sockets(void)
922{
e2174ca4
GP		 923 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
924 BT_ERR("L2CAP socket unregistration failed");
bb58f747 925
e2174ca4 926 proto_unregister(&l2cap_proto);
bb58f747 927}
kernel source for telekom puls (alcatel/mediatek)