projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'vfree' into for-next
[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.
590051de 6 Copyright (C) 2011 ProFUSION Embedded Systems
bb58f747
GP		 7
8 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License version 2 as
12 published by the Free Software Foundation;
13
14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
15 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
17 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
18 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
20 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
21 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
22
23 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
24 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
25 SOFTWARE IS DISCLAIMED.
26*/
27
28/* Bluetooth L2CAP sockets. */
29
bc3b2d7f 30#include <linux/export.h>
6230c9b4 31
bb58f747 32#include <net/bluetooth/bluetooth.h>
33575df7 33#include <net/bluetooth/hci_core.h>
bb58f747 34#include <net/bluetooth/l2cap.h>
f1cb9af5 35#include <net/bluetooth/smp.h>
bb58f747 36
5b28d95c
MY		 37static struct bt_sock_list l2cap_sk_list = {
38 .lock = __RW_LOCK_UNLOCKED(l2cap_sk_list.lock)
39};
40
cf2f90f5 41static const struct proto_ops l2cap_sock_ops;
80808e43 42static void l2cap_sock_init(struct sock *sk, struct sock *parent);
2d792818
GP		 43static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
44 int proto, gfp_t prio);
cf2f90f5 45
af6bcd82
GP		 46static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
47{
48 struct sock *sk = sock->sk;
4343478f 49 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
af6bcd82
GP		 50 struct sockaddr_l2 la;
51 int len, err = 0;
52
53 BT_DBG("sk %p", sk);
54
55 if (!addr || addr->sa_family != AF_BLUETOOTH)
56 return -EINVAL;
57
58 memset(&la, 0, sizeof(la));
59 len = min_t(unsigned int, sizeof(la), alen);
60 memcpy(&la, addr, len);
61
b62f328b 62 if (la.l2_cid && la.l2_psm)
af6bcd82
GP		 63 return -EINVAL;
64
65 lock_sock(sk);
66
67 if (sk->sk_state != BT_OPEN) {
68 err = -EBADFD;
69 goto done;
70 }
71
72 if (la.l2_psm) {
73 __u16 psm = __le16_to_cpu(la.l2_psm);
74
75 /* PSM must be odd and lsb of upper byte must be 0 */
76 if ((psm & 0x0101) != 0x0001) {
77 err = -EINVAL;
78 goto done;
79 }
80
81 /* Restrict usage of well-known PSMs */
82 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
83 err = -EACCES;
84 goto done;
85 }
86 }
87
9e4425ff 88 if (la.l2_cid)
6e4aff10 89 err = l2cap_add_scid(chan, __le16_to_cpu(la.l2_cid));
9e4425ff
GP		 90 else
91 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
af6bcd82 92
9e4425ff
GP		 93 if (err < 0)
94 goto done;
af6bcd82 95
2983fd68
AE		 96 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_SDP ||
97 __le16_to_cpu(la.l2_psm) == L2CAP_PSM_RFCOMM)
9e4425ff 98 chan->sec_level = BT_SECURITY_SDP;
b62f328b 99
9e4425ff 100 bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
89bc500e
GP		 101
102 chan->state = BT_BOUND;
9e4425ff 103 sk->sk_state = BT_BOUND;
af6bcd82
GP		 104
105done:
106 release_sock(sk);
107 return err;
108}
109
2d792818
GP		 110static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr,
111 int alen, int flags)
4e34c50b
GP		 112{
113 struct sock *sk = sock->sk;
0c1bc5c6 114 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
4e34c50b
GP		 115 struct sockaddr_l2 la;
116 int len, err = 0;
117
118 BT_DBG("sk %p", sk);
119
120 if (!addr || alen < sizeof(addr->sa_family) ||
121 addr->sa_family != AF_BLUETOOTH)
122 return -EINVAL;
123
124 memset(&la, 0, sizeof(la));
125 len = min_t(unsigned int, sizeof(la), alen);
126 memcpy(&la, addr, len);
127
acd7d370 128 if (la.l2_cid && la.l2_psm)
4e34c50b
GP		 129 return -EINVAL;
130
6e4aff10 131 err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),
8e9f9892 132 &la.l2_bdaddr, la.l2_bdaddr_type);
4e34c50b 133 if (err)
b3fb611e 134 return err;
4e34c50b 135
6be36555
AE		 136 lock_sock(sk);
137
4e34c50b 138 err = bt_sock_wait_state(sk, BT_CONNECTED,
2d792818 139 sock_sndtimeo(sk, flags & O_NONBLOCK));
b3fb611e
AE		 140
141 release_sock(sk);
142
4e34c50b
GP		 143 return err;
144}
145
af6bcd82
GP		 146static int l2cap_sock_listen(struct socket *sock, int backlog)
147{
148 struct sock *sk = sock->sk;
0c1bc5c6 149 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
af6bcd82
GP		 150 int err = 0;
151
152 BT_DBG("sk %p backlog %d", sk, backlog);
153
154 lock_sock(sk);
155
6b3af733 156 if (sk->sk_state != BT_BOUND) {
af6bcd82
GP		 157 err = -EBADFD;
158 goto done;
159 }
160
6b3af733
MH		 161 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM) {
162 err = -EINVAL;
163 goto done;
164 }
165
0c1bc5c6 166 switch (chan->mode) {
af6bcd82
GP		 167 case L2CAP_MODE_BASIC:
168 break;
169 case L2CAP_MODE_ERTM:
170 case L2CAP_MODE_STREAMING:
171 if (!disable_ertm)
172 break;
173 /* fall through */
174 default:
175 err = -ENOTSUPP;
176 goto done;
177 }
178
af6bcd82
GP		 179 sk->sk_max_ack_backlog = backlog;
180 sk->sk_ack_backlog = 0;
89bc500e
GP		 181
182 chan->state = BT_LISTEN;
af6bcd82
GP		 183 sk->sk_state = BT_LISTEN;
184
185done:
186 release_sock(sk);
187 return err;
188}
189
2d792818
GP		 190static int l2cap_sock_accept(struct socket *sock, struct socket *newsock,
191 int flags)
c47b7c72
GP		 192{
193 DECLARE_WAITQUEUE(wait, current);
194 struct sock *sk = sock->sk, *nsk;
195 long timeo;
196 int err = 0;
197
198 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
199
c47b7c72
GP		 200 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
201
202 BT_DBG("sk %p timeo %ld", sk, timeo);
203
204 /* Wait for an incoming connection. (wake-one). */
205 add_wait_queue_exclusive(sk_sleep(sk), &wait);
f9a3c20a 206 while (1) {
c47b7c72 207 set_current_state(TASK_INTERRUPTIBLE);
f9a3c20a
PH		 208
209 if (sk->sk_state != BT_LISTEN) {
210 err = -EBADFD;
c47b7c72
GP		 211 break;
212 }
213
f9a3c20a
PH		 214 nsk = bt_accept_dequeue(sk, newsock);
215 if (nsk)
216 break;
c47b7c72 217
f9a3c20a
PH		 218 if (!timeo) {
219 err = -EAGAIN;
c47b7c72
GP		 220 break;
221 }
222
223 if (signal_pending(current)) {
224 err = sock_intr_errno(timeo);
225 break;
226 }
f9a3c20a
PH		 227
228 release_sock(sk);
229 timeo = schedule_timeout(timeo);
230 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
c47b7c72 231 }
f9a3c20a 232 __set_current_state(TASK_RUNNING);
c47b7c72
GP		 233 remove_wait_queue(sk_sleep(sk), &wait);
234
235 if (err)
236 goto done;
237
238 newsock->state = SS_CONNECTED;
239
240 BT_DBG("new socket %p", nsk);
241
242done:
243 release_sock(sk);
244 return err;
245}
246
2d792818
GP		 247static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr,
248 int *len, int peer)
d7175d55
GP		 249{
250 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
251 struct sock *sk = sock->sk;
0c1bc5c6 252 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
d7175d55
GP		 253
254 BT_DBG("sock %p, sk %p", sock, sk);
255
792039c7 256 memset(la, 0, sizeof(struct sockaddr_l2));
d7175d55
GP		 257 addr->sa_family = AF_BLUETOOTH;
258 *len = sizeof(struct sockaddr_l2);
259
260 if (peer) {
fe4128e0 261 la->l2_psm = chan->psm;
d7175d55 262 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
fe4128e0 263 la->l2_cid = cpu_to_le16(chan->dcid);
d7175d55 264 } else {
0c1bc5c6 265 la->l2_psm = chan->sport;
d7175d55 266 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
fe4128e0 267 la->l2_cid = cpu_to_le16(chan->scid);
d7175d55
GP		 268 }
269
270 return 0;
271}
272
2d792818
GP		 273static int l2cap_sock_getsockopt_old(struct socket *sock, int optname,
274 char __user *optval, int __user *optlen)
99f4808d
GP		 275{
276 struct sock *sk = sock->sk;
4343478f 277 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
99f4808d
GP		 278 struct l2cap_options opts;
279 struct l2cap_conninfo cinfo;
280 int len, err = 0;
281 u32 opt;
282
283 BT_DBG("sk %p", sk);
284
285 if (get_user(len, optlen))
286 return -EFAULT;
287
288 lock_sock(sk);
289
290 switch (optname) {
291 case L2CAP_OPTIONS:
e3fb592b 292 memset(&opts, 0, sizeof(opts));
0c1bc5c6
GP		 293 opts.imtu = chan->imtu;
294 opts.omtu = chan->omtu;
295 opts.flush_to = chan->flush_to;
296 opts.mode = chan->mode;
47d1ec61
GP		 297 opts.fcs = chan->fcs;
298 opts.max_tx = chan->max_tx;
6327eb98 299 opts.txwin_size = chan->tx_win;
99f4808d
GP		 300
301 len = min_t(unsigned int, len, sizeof(opts));
302 if (copy_to_user(optval, (char *) &opts, len))
303 err = -EFAULT;
304
305 break;
306
307 case L2CAP_LM:
4343478f 308 switch (chan->sec_level) {
99f4808d
GP		 309 case BT_SECURITY_LOW:
310 opt = L2CAP_LM_AUTH;
311 break;
312 case BT_SECURITY_MEDIUM:
313 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
314 break;
315 case BT_SECURITY_HIGH:
316 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
2d792818 317 L2CAP_LM_SECURE;
99f4808d
GP		 318 break;
319 default:
320 opt = 0;
321 break;
322 }
323
43bd0f32 324 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
99f4808d
GP		 325 opt |= L2CAP_LM_MASTER;
326
ecf61bdb 327 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
99f4808d
GP		 328 opt |= L2CAP_LM_RELIABLE;
329
330 if (put_user(opt, (u32 __user *) optval))
331 err = -EFAULT;
332 break;
333
334 case L2CAP_CONNINFO:
335 if (sk->sk_state != BT_CONNECTED &&
c5daa683
GP		 336 !(sk->sk_state == BT_CONNECT2 &&
337 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
99f4808d
GP		 338 err = -ENOTCONN;
339 break;
340 }
341
8d03e971 342 memset(&cinfo, 0, sizeof(cinfo));
8c1d787b
GP		 343 cinfo.hci_handle = chan->conn->hcon->handle;
344 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
99f4808d
GP		 345
346 len = min_t(unsigned int, len, sizeof(cinfo));
347 if (copy_to_user(optval, (char *) &cinfo, len))
348 err = -EFAULT;
349
350 break;
351
352 default:
353 err = -ENOPROTOOPT;
354 break;
355 }
356
357 release_sock(sk);
358 return err;
359}
360
2d792818
GP		 361static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname,
362 char __user *optval, int __user *optlen)
99f4808d
GP		 363{
364 struct sock *sk = sock->sk;
4343478f 365 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
99f4808d 366 struct bt_security sec;
14b12d0b 367 struct bt_power pwr;
99f4808d
GP		 368 int len, err = 0;
369
370 BT_DBG("sk %p", sk);
371
372 if (level == SOL_L2CAP)
373 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
374
375 if (level != SOL_BLUETOOTH)
376 return -ENOPROTOOPT;
377
378 if (get_user(len, optlen))
379 return -EFAULT;
380
381 lock_sock(sk);
382
383 switch (optname) {
384 case BT_SECURITY:
715ec005 385 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
2d792818 386 chan->chan_type != L2CAP_CHAN_RAW) {
99f4808d
GP		 387 err = -EINVAL;
388 break;
389 }
390
8f360119 391 memset(&sec, 0, sizeof(sec));
85e34368 392 if (chan->conn) {
c6585a4d 393 sec.level = chan->conn->hcon->sec_level;
99f4808d 394
85e34368
AE		 395 if (sk->sk_state == BT_CONNECTED)
396 sec.key_size = chan->conn->hcon->enc_key_size;
397 } else {
398 sec.level = chan->sec_level;
399 }
8f360119 400
99f4808d
GP		 401 len = min_t(unsigned int, len, sizeof(sec));
402 if (copy_to_user(optval, (char *) &sec, len))
403 err = -EFAULT;
404
405 break;
406
407 case BT_DEFER_SETUP:
408 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
409 err = -EINVAL;
410 break;
411 }
412
c5daa683
GP		 413 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
414 (u32 __user *) optval))
99f4808d
GP		 415 err = -EFAULT;
416
417 break;
418
419 case BT_FLUSHABLE:
d57b0e8b 420 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
2d792818 421 (u32 __user *) optval))
99f4808d
GP		 422 err = -EFAULT;
423
424 break;
425
14b12d0b
JG		 426 case BT_POWER:
427 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
2d792818 428 && sk->sk_type != SOCK_RAW) {
14b12d0b
JG		 429 err = -EINVAL;
430 break;
431 }
432
15770b1a 433 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
14b12d0b
JG		 434
435 len = min_t(unsigned int, len, sizeof(pwr));
436 if (copy_to_user(optval, (char *) &pwr, len))
437 err = -EFAULT;
438
439 break;
440
2ea66482
MM		 441 case BT_CHANNEL_POLICY:
442 if (!enable_hs) {
443 err = -ENOPROTOOPT;
444 break;
445 }
446
447 if (put_user(chan->chan_policy, (u32 __user *) optval))
448 err = -EFAULT;
449 break;
450
99f4808d
GP		 451 default:
452 err = -ENOPROTOOPT;
453 break;
454 }
455
456 release_sock(sk);
457 return err;
458}
459
682877c3
AG		 460static bool l2cap_valid_mtu(struct l2cap_chan *chan, u16 mtu)
461{
462 switch (chan->scid) {
463 case L2CAP_CID_LE_DATA:
8c3a4f00 464 if (mtu < L2CAP_LE_MIN_MTU)
682877c3
AG		 465 return false;
466 break;
467
468 default:
469 if (mtu < L2CAP_DEFAULT_MIN_MTU)
470 return false;
471 }
472
473 return true;
474}
475
2d792818
GP		 476static int l2cap_sock_setsockopt_old(struct socket *sock, int optname,
477 char __user *optval, unsigned int optlen)
33575df7
GP		 478{
479 struct sock *sk = sock->sk;
b4450035 480 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
33575df7
GP		 481 struct l2cap_options opts;
482 int len, err = 0;
483 u32 opt;
484
485 BT_DBG("sk %p", sk);
486
487 lock_sock(sk);
488
489 switch (optname) {
490 case L2CAP_OPTIONS:
491 if (sk->sk_state == BT_CONNECTED) {
492 err = -EINVAL;
493 break;
494 }
495
0c1bc5c6
GP		 496 opts.imtu = chan->imtu;
497 opts.omtu = chan->omtu;
498 opts.flush_to = chan->flush_to;
499 opts.mode = chan->mode;
47d1ec61
GP		 500 opts.fcs = chan->fcs;
501 opts.max_tx = chan->max_tx;
6327eb98 502 opts.txwin_size = chan->tx_win;
33575df7
GP		 503
504 len = min_t(unsigned int, sizeof(opts), optlen);
505 if (copy_from_user((char *) &opts, optval, len)) {
506 err = -EFAULT;
507 break;
508 }
509
6327eb98 510 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
33575df7
GP		 511 err = -EINVAL;
512 break;
513 }
514
682877c3
AG		 515 if (!l2cap_valid_mtu(chan, opts.imtu)) {
516 err = -EINVAL;
517 break;
518 }
519
0c1bc5c6
GP		 520 chan->mode = opts.mode;
521 switch (chan->mode) {
33575df7 522 case L2CAP_MODE_BASIC:
c1360a1c 523 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
33575df7
GP		 524 break;
525 case L2CAP_MODE_ERTM:
526 case L2CAP_MODE_STREAMING:
527 if (!disable_ertm)
528 break;
529 /* fall through */
530 default:
531 err = -EINVAL;
532 break;
533 }
534
0c1bc5c6
GP		 535 chan->imtu = opts.imtu;
536 chan->omtu = opts.omtu;
47d1ec61
GP		 537 chan->fcs = opts.fcs;
538 chan->max_tx = opts.max_tx;
6327eb98 539 chan->tx_win = opts.txwin_size;
12d59781 540 chan->flush_to = opts.flush_to;
33575df7
GP		 541 break;
542
543 case L2CAP_LM:
544 if (get_user(opt, (u32 __user *) optval)) {
545 err = -EFAULT;
546 break;
547 }
548
549 if (opt & L2CAP_LM_AUTH)
4343478f 550 chan->sec_level = BT_SECURITY_LOW;
33575df7 551 if (opt & L2CAP_LM_ENCRYPT)
4343478f 552 chan->sec_level = BT_SECURITY_MEDIUM;
33575df7 553 if (opt & L2CAP_LM_SECURE)
4343478f 554 chan->sec_level = BT_SECURITY_HIGH;
33575df7 555
43bd0f32
AE		 556 if (opt & L2CAP_LM_MASTER)
557 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
558 else
559 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
ecf61bdb
AE		 560
561 if (opt & L2CAP_LM_RELIABLE)
562 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
563 else
564 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
33575df7
GP		 565 break;
566
567 default:
568 err = -ENOPROTOOPT;
569 break;
570 }
571
572 release_sock(sk);
573 return err;
574}
575
2d792818
GP		 576static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
577 char __user *optval, unsigned int optlen)
33575df7
GP		 578{
579 struct sock *sk = sock->sk;
4343478f 580 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
33575df7 581 struct bt_security sec;
14b12d0b 582 struct bt_power pwr;
f1cb9af5 583 struct l2cap_conn *conn;
33575df7
GP		 584 int len, err = 0;
585 u32 opt;
586
587 BT_DBG("sk %p", sk);
588
589 if (level == SOL_L2CAP)
590 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
591
592 if (level != SOL_BLUETOOTH)
593 return -ENOPROTOOPT;
594
595 lock_sock(sk);
596
597 switch (optname) {
598 case BT_SECURITY:
715ec005 599 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
2d792818 600 chan->chan_type != L2CAP_CHAN_RAW) {
33575df7
GP		 601 err = -EINVAL;
602 break;
603 }
604
605 sec.level = BT_SECURITY_LOW;
606
607 len = min_t(unsigned int, sizeof(sec), optlen);
608 if (copy_from_user((char *) &sec, optval, len)) {
609 err = -EFAULT;
610 break;
611 }
612
613 if (sec.level < BT_SECURITY_LOW ||
2d792818 614 sec.level > BT_SECURITY_HIGH) {
33575df7
GP		 615 err = -EINVAL;
616 break;
617 }
618
4343478f 619 chan->sec_level = sec.level;
f1cb9af5 620
0bee1d60
GP		 621 if (!chan->conn)
622 break;
623
f1cb9af5 624 conn = chan->conn;
0bee1d60
GP		 625
626 /*change security for LE channels */
627 if (chan->scid == L2CAP_CID_LE_DATA) {
f1cb9af5
VCG		 628 if (!conn->hcon->out) {
629 err = -EINVAL;
630 break;
631 }
632
cc110922 633 if (smp_conn_security(conn->hcon, sec.level))
f1cb9af5 634 break;
f1cb9af5 635 sk->sk_state = BT_CONFIG;
3542b854 636 chan->state = BT_CONFIG;
0bee1d60 637
a7d7723a
GP		 638 /* or for ACL link */
639 } else if ((sk->sk_state == BT_CONNECT2 &&
2d792818 640 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) ||
a7d7723a
GP		 641 sk->sk_state == BT_CONNECTED) {
642 if (!l2cap_chan_check_security(chan))
c5daa683 643 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
a7d7723a
GP		 644 else
645 sk->sk_state_change(sk);
0bee1d60
GP		 646 } else {
647 err = -EINVAL;
f1cb9af5 648 }
33575df7
GP		 649 break;
650
651 case BT_DEFER_SETUP:
652 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
653 err = -EINVAL;
654 break;
655 }
656
657 if (get_user(opt, (u32 __user *) optval)) {
658 err = -EFAULT;
659 break;
660 }
661
c5daa683
GP		 662 if (opt)
663 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
664 else
665 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
33575df7
GP		 666 break;
667
668 case BT_FLUSHABLE:
669 if (get_user(opt, (u32 __user *) optval)) {
670 err = -EFAULT;
671 break;
672 }
673
674 if (opt > BT_FLUSHABLE_ON) {
675 err = -EINVAL;
676 break;
677 }
678
679 if (opt == BT_FLUSHABLE_OFF) {
8c1d787b 680 struct l2cap_conn *conn = chan->conn;
25985edc 681 /* proceed further only when we have l2cap_conn and
33575df7
GP		 682 No Flush support in the LM */
683 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
684 err = -EINVAL;
685 break;
686 }
687 }
688
d57b0e8b
AE		 689 if (opt)
690 set_bit(FLAG_FLUSHABLE, &chan->flags);
691 else
692 clear_bit(FLAG_FLUSHABLE, &chan->flags);
33575df7
GP		 693 break;
694
14b12d0b
JG		 695 case BT_POWER:
696 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
2d792818 697 chan->chan_type != L2CAP_CHAN_RAW) {
14b12d0b
JG		 698 err = -EINVAL;
699 break;
700 }
701
702 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
703
704 len = min_t(unsigned int, sizeof(pwr), optlen);
705 if (copy_from_user((char *) &pwr, optval, len)) {
706 err = -EFAULT;
707 break;
708 }
15770b1a
AE		 709
710 if (pwr.force_active)
711 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
712 else
713 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
14b12d0b
JG		 714 break;
715
2ea66482
MM		 716 case BT_CHANNEL_POLICY:
717 if (!enable_hs) {
718 err = -ENOPROTOOPT;
719 break;
720 }
721
722 if (get_user(opt, (u32 __user *) optval)) {
723 err = -EFAULT;
724 break;
725 }
726
727 if (opt > BT_CHANNEL_POLICY_AMP_PREFERRED) {
728 err = -EINVAL;
729 break;
730 }
731
732 if (chan->mode != L2CAP_MODE_ERTM &&
2d792818 733 chan->mode != L2CAP_MODE_STREAMING) {
2ea66482
MM		 734 err = -EOPNOTSUPP;
735 break;
736 }
737
738 chan->chan_policy = (u8) opt;
3f7a56c4
MM		 739
740 if (sk->sk_state == BT_CONNECTED &&
741 chan->move_role == L2CAP_MOVE_ROLE_NONE)
742 l2cap_move_start(chan);
743
14b12d0b
JG		 744 break;
745
33575df7
GP		 746 default:
747 err = -ENOPROTOOPT;
748 break;
749 }
750
751 release_sock(sk);
752 return err;
753}
fd83ccdb 754
2d792818
GP		 755static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
756 struct msghdr *msg, size_t len)
fd83ccdb
GP		 757{
758 struct sock *sk = sock->sk;
0c1bc5c6 759 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
fd83ccdb
GP		 760 int err;
761
762 BT_DBG("sock %p, sk %p", sock, sk);
763
764 err = sock_error(sk);
765 if (err)
766 return err;
767
768 if (msg->msg_flags & MSG_OOB)
769 return -EOPNOTSUPP;
770
a6a5568c 771 if (sk->sk_state != BT_CONNECTED)
9a91a04a 772 return -ENOTCONN;
fd83ccdb 773
a6a5568c 774 l2cap_chan_lock(chan);
5e59b791 775 err = l2cap_chan_send(chan, msg, len, sk->sk_priority);
a6a5568c 776 l2cap_chan_unlock(chan);
fd83ccdb 777
fd83ccdb
GP		 778 return err;
779}
33575df7 780
2d792818
GP		 781static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
782 struct msghdr *msg, size_t len, int flags)
68983259
GP		 783{
784 struct sock *sk = sock->sk;
e328140f
MM		 785 struct l2cap_pinfo *pi = l2cap_pi(sk);
786 int err;
68983259
GP		 787
788 lock_sock(sk);
789
c5daa683
GP		 790 if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
791 &bt_sk(sk)->flags)) {
8c1d787b 792 sk->sk_state = BT_CONFIG;
3542b854 793 pi->chan->state = BT_CONFIG;
8c1d787b 794
e328140f 795 __l2cap_connect_rsp_defer(pi->chan);
68983259
GP		 796 release_sock(sk);
797 return 0;
798 }
799
800 release_sock(sk);
801
802 if (sock->type == SOCK_STREAM)
e328140f
MM		 803 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
804 else
805 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
806
807 if (pi->chan->mode != L2CAP_MODE_ERTM)
808 return err;
809
810 /* Attempt to put pending rx data in the socket buffer */
811
812 lock_sock(sk);
813
814 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
815 goto done;
816
817 if (pi->rx_busy_skb) {
818 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
819 pi->rx_busy_skb = NULL;
820 else
821 goto done;
822 }
823
824 /* Restore data flow when half of the receive buffer is
825 * available. This avoids resending large numbers of
826 * frames.
827 */
828 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
829 l2cap_chan_busy(pi->chan, 0);
68983259 830
e328140f
MM		 831done:
832 release_sock(sk);
833 return err;
68983259
GP		 834}
835
05fc1576
GP		 836/* Kill socket (only if zapped and orphan)
837 * Must be called on unlocked socket.
838 */
ba3bd0ee 839static void l2cap_sock_kill(struct sock *sk)
05fc1576
GP		 840{
841 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
842 return;
843
e05dcc32 844 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
05fc1576
GP		 845
846 /* Kill poor orphan */
6ff5abbf 847
4af66c69 848 l2cap_chan_put(l2cap_pi(sk)->chan);
05fc1576
GP		 849 sock_set_flag(sk, SOCK_DEAD);
850 sock_put(sk);
851}
852
dcba0dba
GP		 853static int l2cap_sock_shutdown(struct socket *sock, int how)
854{
855 struct sock *sk = sock->sk;
7ddb6e0f 856 struct l2cap_chan *chan;
3df91ea2 857 struct l2cap_conn *conn;
dcba0dba
GP		 858 int err = 0;
859
860 BT_DBG("sock %p, sk %p", sock, sk);
861
862 if (!sk)
863 return 0;
864
7ddb6e0f 865 chan = l2cap_pi(sk)->chan;
3df91ea2
AE		 866 conn = chan->conn;
867
868 if (conn)
869 mutex_lock(&conn->chan_lock);
7ddb6e0f 870
6be36555 871 l2cap_chan_lock(chan);
dcba0dba 872 lock_sock(sk);
6be36555 873
dcba0dba 874 if (!sk->sk_shutdown) {
0c1bc5c6 875 if (chan->mode == L2CAP_MODE_ERTM)
dcba0dba
GP		 876 err = __l2cap_wait_ack(sk);
877
878 sk->sk_shutdown = SHUTDOWN_MASK;
3df91ea2 879
6be36555 880 release_sock(sk);
0f852724 881 l2cap_chan_close(chan, 0);
6be36555 882 lock_sock(sk);
dcba0dba
GP		 883
884 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
885 err = bt_sock_wait_state(sk, BT_CLOSED,
2d792818 886 sk->sk_lingertime);
dcba0dba
GP		 887 }
888
889 if (!err && sk->sk_err)
890 err = -sk->sk_err;
891
892 release_sock(sk);
6be36555 893 l2cap_chan_unlock(chan);
3df91ea2
AE		 894
895 if (conn)
896 mutex_unlock(&conn->chan_lock);
897
dcba0dba
GP		 898 return err;
899}
900
554f05bb
GP		 901static int l2cap_sock_release(struct socket *sock)
902{
903 struct sock *sk = sock->sk;
904 int err;
905
906 BT_DBG("sock %p, sk %p", sock, sk);
907
908 if (!sk)
909 return 0;
910
5b28d95c
MY		 911 bt_sock_unlink(&l2cap_sk_list, sk);
912
554f05bb
GP		 913 err = l2cap_sock_shutdown(sock, 2);
914
915 sock_orphan(sk);
916 l2cap_sock_kill(sk);
917 return err;
918}
919
c0df7f6e
AE		 920static void l2cap_sock_cleanup_listen(struct sock *parent)
921{
922 struct sock *sk;
923
924 BT_DBG("parent %p", parent);
925
926 /* Close not yet accepted channels */
927 while ((sk = bt_accept_dequeue(parent, NULL))) {
928 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
929
930 l2cap_chan_lock(chan);
931 __clear_chan_timer(chan);
932 l2cap_chan_close(chan, ECONNRESET);
933 l2cap_chan_unlock(chan);
934
935 l2cap_sock_kill(sk);
936 }
937}
938
80b98027 939static struct l2cap_chan *l2cap_sock_new_connection_cb(struct l2cap_chan *chan)
80808e43 940{
80b98027 941 struct sock *sk, *parent = chan->data;
80808e43 942
53826692
GP		 943 /* Check for backlog size */
944 if (sk_acceptq_is_full(parent)) {
945 BT_DBG("backlog full %d", parent->sk_ack_backlog);
946 return NULL;
947 }
948
80808e43 949 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
2d792818 950 GFP_ATOMIC);
80808e43
GP		 951 if (!sk)
952 return NULL;
953
d22015aa
OP		 954 bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
955
80808e43
GP		 956 l2cap_sock_init(sk, parent);
957
644912e1
GP		 958 bt_accept_enqueue(parent, sk);
959
80808e43
GP		 960 return l2cap_pi(sk)->chan;
961}
962
80b98027 963static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
23070494 964{
e328140f 965 int err;
80b98027 966 struct sock *sk = chan->data;
e328140f
MM		 967 struct l2cap_pinfo *pi = l2cap_pi(sk);
968
6be36555
AE		 969 lock_sock(sk);
970
971 if (pi->rx_busy_skb) {
972 err = -ENOMEM;
973 goto done;
974 }
e328140f
MM		 975
976 err = sock_queue_rcv_skb(sk, skb);
977
978 /* For ERTM, handle one skb that doesn't fit into the recv
979 * buffer. This is important to do because the data frames
980 * have already been acked, so the skb cannot be discarded.
981 *
982 * Notify the l2cap core that the buffer is full, so the
983 * LOCAL_BUSY state is entered and no more frames are
984 * acked and reassembled until there is buffer space
985 * available.
986 */
987 if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
988 pi->rx_busy_skb = skb;
989 l2cap_chan_busy(pi->chan, 1);
990 err = 0;
991 }
23070494 992
6be36555
AE		 993done:
994 release_sock(sk);
995
e328140f 996 return err;
23070494
GP		 997}
998
80b98027 999static void l2cap_sock_close_cb(struct l2cap_chan *chan)
ba3bd0ee 1000{
80b98027 1001 struct sock *sk = chan->data;
ba3bd0ee
GP		 1002
1003 l2cap_sock_kill(sk);
1004}
1005
c0df7f6e
AE		 1006static void l2cap_sock_teardown_cb(struct l2cap_chan *chan, int err)
1007{
1008 struct sock *sk = chan->data;
1009 struct sock *parent;
1010
1011 lock_sock(sk);
1012
1013 parent = bt_sk(sk)->parent;
1014
1015 sock_set_flag(sk, SOCK_ZAPPED);
1016
1017 switch (chan->state) {
1018 case BT_OPEN:
1019 case BT_BOUND:
1020 case BT_CLOSED:
1021 break;
1022 case BT_LISTEN:
1023 l2cap_sock_cleanup_listen(sk);
1024 sk->sk_state = BT_CLOSED;
1025 chan->state = BT_CLOSED;
1026
1027 break;
1028 default:
1029 sk->sk_state = BT_CLOSED;
1030 chan->state = BT_CLOSED;
1031
1032 sk->sk_err = err;
1033
1034 if (parent) {
1035 bt_accept_unlink(sk);
1036 parent->sk_data_ready(parent, 0);
1037 } else {
1038 sk->sk_state_change(sk);
1039 }
1040
1041 break;
1042 }
1043
1044 release_sock(sk);
1045}
1046
80b98027 1047static void l2cap_sock_state_change_cb(struct l2cap_chan *chan, int state)
89bc500e 1048{
80b98027 1049 struct sock *sk = chan->data;
89bc500e
GP		 1050
1051 sk->sk_state = state;
1052}
1053
2f7719ce 1054static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
90338947 1055 unsigned long len, int nb)
2f7719ce 1056{
90338947
GP		 1057 struct sk_buff *skb;
1058 int err;
1059
a6a5568c 1060 l2cap_chan_unlock(chan);
90338947 1061 skb = bt_skb_send_alloc(chan->sk, len, nb, &err);
a6a5568c
MM		 1062 l2cap_chan_lock(chan);
1063
90338947
GP		 1064 if (!skb)
1065 return ERR_PTR(err);
2f7719ce 1066
90338947 1067 return skb;
2f7719ce
AE		 1068}
1069
54a59aa2
AE		 1070static void l2cap_sock_ready_cb(struct l2cap_chan *chan)
1071{
1072 struct sock *sk = chan->data;
1073 struct sock *parent;
1074
1075 lock_sock(sk);
1076
1077 parent = bt_sk(sk)->parent;
1078
1079 BT_DBG("sk %p, parent %p", sk, parent);
1080
1081 sk->sk_state = BT_CONNECTED;
1082 sk->sk_state_change(sk);
1083
1084 if (parent)
1085 parent->sk_data_ready(parent, 0);
1086
1087 release_sock(sk);
1088}
1089
2dc4e510
GP		 1090static void l2cap_sock_defer_cb(struct l2cap_chan *chan)
1091{
1092 struct sock *sk = chan->data;
1093 struct sock *parent = bt_sk(sk)->parent;
1094
1095 if (parent)
1096 parent->sk_data_ready(parent, 0);
1097}
1098
80808e43
GP		 1099static struct l2cap_ops l2cap_chan_ops = {
1100 .name = "L2CAP Socket Interface",
1101 .new_connection = l2cap_sock_new_connection_cb,
23070494 1102 .recv = l2cap_sock_recv_cb,
ba3bd0ee 1103 .close = l2cap_sock_close_cb,
c0df7f6e 1104 .teardown = l2cap_sock_teardown_cb,
89bc500e 1105 .state_change = l2cap_sock_state_change_cb,
54a59aa2 1106 .ready = l2cap_sock_ready_cb,
2dc4e510 1107 .defer = l2cap_sock_defer_cb,
2f7719ce 1108 .alloc_skb = l2cap_sock_alloc_skb_cb,
80808e43
GP		 1109};
1110
bb58f747
GP		 1111static void l2cap_sock_destruct(struct sock *sk)
1112{
1113 BT_DBG("sk %p", sk);
1114
23d3a869
SL		 1115 if (l2cap_pi(sk)->chan)
1116 l2cap_chan_put(l2cap_pi(sk)->chan);
e328140f
MM		 1117 if (l2cap_pi(sk)->rx_busy_skb) {
1118 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
1119 l2cap_pi(sk)->rx_busy_skb = NULL;
1120 }
1121
bb58f747
GP		 1122 skb_queue_purge(&sk->sk_receive_queue);
1123 skb_queue_purge(&sk->sk_write_queue);
1124}
1125
80808e43 1126static void l2cap_sock_init(struct sock *sk, struct sock *parent)
bb58f747
GP		 1127{
1128 struct l2cap_pinfo *pi = l2cap_pi(sk);
b4450035 1129 struct l2cap_chan *chan = pi->chan;
bb58f747
GP		 1130
1131 BT_DBG("sk %p", sk);
1132
1133 if (parent) {
b4450035
GP		 1134 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1135
bb58f747 1136 sk->sk_type = parent->sk_type;
c5daa683 1137 bt_sk(sk)->flags = bt_sk(parent)->flags;
bb58f747 1138
715ec005 1139 chan->chan_type = pchan->chan_type;
0c1bc5c6
GP		 1140 chan->imtu = pchan->imtu;
1141 chan->omtu = pchan->omtu;
b4450035 1142 chan->conf_state = pchan->conf_state;
0c1bc5c6 1143 chan->mode = pchan->mode;
47d1ec61
GP		 1144 chan->fcs = pchan->fcs;
1145 chan->max_tx = pchan->max_tx;
1146 chan->tx_win = pchan->tx_win;
6b3c7104 1147 chan->tx_win_max = pchan->tx_win_max;
4343478f 1148 chan->sec_level = pchan->sec_level;
d57b0e8b 1149 chan->flags = pchan->flags;
6230c9b4
PM		 1150
1151 security_sk_clone(parent, sk);
bb58f747 1152 } else {
715ec005
GP		 1153
1154 switch (sk->sk_type) {
1155 case SOCK_RAW:
1156 chan->chan_type = L2CAP_CHAN_RAW;
1157 break;
1158 case SOCK_DGRAM:
1159 chan->chan_type = L2CAP_CHAN_CONN_LESS;
1160 break;
1161 case SOCK_SEQPACKET:
1162 case SOCK_STREAM:
1163 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1164 break;
1165 }
1166
0c1bc5c6
GP		 1167 chan->imtu = L2CAP_DEFAULT_MTU;
1168 chan->omtu = 0;
bb58f747 1169 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
0c1bc5c6 1170 chan->mode = L2CAP_MODE_ERTM;
c1360a1c 1171 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
bb58f747 1172 } else {
0c1bc5c6 1173 chan->mode = L2CAP_MODE_BASIC;
bb58f747 1174 }
bd4b1653
AE		 1175
1176 l2cap_chan_set_defaults(chan);
bb58f747
GP		 1177 }
1178
1179 /* Default config options */
0c1bc5c6 1180 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
80808e43
GP		 1181
1182 chan->data = sk;
1183 chan->ops = &l2cap_chan_ops;
bb58f747
GP		 1184}
1185
1186static struct proto l2cap_proto = {
1187 .name = "L2CAP",
1188 .owner = THIS_MODULE,
1189 .obj_size = sizeof(struct l2cap_pinfo)
1190};
1191
2d792818
GP		 1192static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
1193 int proto, gfp_t prio)
bb58f747
GP		 1194{
1195 struct sock *sk;
dc50a06d 1196 struct l2cap_chan *chan;
bb58f747
GP		 1197
1198 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1199 if (!sk)
1200 return NULL;
1201
1202 sock_init_data(sock, sk);
1203 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1204
1205 sk->sk_destruct = l2cap_sock_destruct;
ba13ccd9 1206 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
bb58f747
GP		 1207
1208 sock_reset_flag(sk, SOCK_ZAPPED);
1209
1210 sk->sk_protocol = proto;
1211 sk->sk_state = BT_OPEN;
1212
eef1d9b6 1213 chan = l2cap_chan_create();
dc50a06d 1214 if (!chan) {
49dfbb91 1215 sk_free(sk);
dc50a06d
GP		 1216 return NULL;
1217 }
1218
61d6ef3e
MM		 1219 l2cap_chan_hold(chan);
1220
eef1d9b6
GP		 1221 chan->sk = sk;
1222
dc50a06d
GP		 1223 l2cap_pi(sk)->chan = chan;
1224
bb58f747
GP		 1225 return sk;
1226}
1227
1228static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1229 int kern)
1230{
1231 struct sock *sk;
1232
1233 BT_DBG("sock %p", sock);
1234
1235 sock->state = SS_UNCONNECTED;
1236
1237 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
2d792818 1238 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
bb58f747
GP		 1239 return -ESOCKTNOSUPPORT;
1240
1241 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1242 return -EPERM;
1243
1244 sock->ops = &l2cap_sock_ops;
1245
1246 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1247 if (!sk)
1248 return -ENOMEM;
1249
1250 l2cap_sock_init(sk, NULL);
5b28d95c 1251 bt_sock_link(&l2cap_sk_list, sk);
bb58f747
GP		 1252 return 0;
1253}
1254
cf2f90f5 1255static const struct proto_ops l2cap_sock_ops = {
65390587
GP		 1256 .family = PF_BLUETOOTH,
1257 .owner = THIS_MODULE,
1258 .release = l2cap_sock_release,
1259 .bind = l2cap_sock_bind,
1260 .connect = l2cap_sock_connect,
1261 .listen = l2cap_sock_listen,
1262 .accept = l2cap_sock_accept,
1263 .getname = l2cap_sock_getname,
1264 .sendmsg = l2cap_sock_sendmsg,
1265 .recvmsg = l2cap_sock_recvmsg,
1266 .poll = bt_sock_poll,
1267 .ioctl = bt_sock_ioctl,
1268 .mmap = sock_no_mmap,
1269 .socketpair = sock_no_socketpair,
1270 .shutdown = l2cap_sock_shutdown,
1271 .setsockopt = l2cap_sock_setsockopt,
1272 .getsockopt = l2cap_sock_getsockopt
1273};
1274
bb58f747
GP		 1275static const struct net_proto_family l2cap_sock_family_ops = {
1276 .family = PF_BLUETOOTH,
1277 .owner = THIS_MODULE,
1278 .create = l2cap_sock_create,
1279};
1280
1281int __init l2cap_init_sockets(void)
1282{
e2174ca4 1283 int err;
bb58f747 1284
e2174ca4
GP		 1285 err = proto_register(&l2cap_proto, 0);
1286 if (err < 0)
1287 return err;
bb58f747 1288
e2174ca4 1289 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
5b28d95c
MY		 1290 if (err < 0) {
1291 BT_ERR("L2CAP socket registration failed");
e2174ca4 1292 goto error;
5b28d95c
MY		 1293 }
1294
b0316615 1295 err = bt_procfs_init(&init_net, "l2cap", &l2cap_sk_list,
2d792818 1296 NULL);
5b28d95c
MY		 1297 if (err < 0) {
1298 BT_ERR("Failed to create L2CAP proc file");
1299 bt_sock_unregister(BTPROTO_L2CAP);
1300 goto error;
1301 }
bb58f747 1302
e2174ca4 1303 BT_INFO("L2CAP socket layer initialized");
bb58f747 1304
e2174ca4 1305 return 0;
bb58f747
GP		 1306
1307error:
e2174ca4
GP		 1308 proto_unregister(&l2cap_proto);
1309 return err;
bb58f747
GP		 1310}
1311
1312void l2cap_cleanup_sockets(void)
1313{
5b28d95c 1314 bt_procfs_cleanup(&init_net, "l2cap");
e2174ca4
GP		 1315 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1316 BT_ERR("L2CAP socket unregistration failed");
bb58f747 1317
e2174ca4 1318 proto_unregister(&l2cap_proto);
bb58f747 1319}
kernel source for telekom puls (alcatel/mediatek)