blob: bf196c67ecb19cea36c6babad04557f578f24652 [file] [log] [blame]
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001/*
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>
Gustavo F. Padovan33575df2011-02-04 02:48:48 -020030#include <net/bluetooth/hci_core.h>
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -020031#include <net/bluetooth/l2cap.h>
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -030032#include <net/bluetooth/smp.h>
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -020033
Gustavo F. Padovancf2f90f2011-04-27 18:40:39 -030034static const struct proto_ops l2cap_sock_ops;
Gustavo F. Padovan80808e42011-05-16 17:24:37 -030035static 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);
Gustavo F. Padovancf2f90f2011-04-27 18:40:39 -030037
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -020038static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
39{
40 struct sock *sk = sock->sk;
Gustavo F. Padovan43434782011-04-12 18:31:57 -030041 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -020042 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
Ville Tervob62f3282011-02-10 22:38:50 -030054 if (la.l2_cid && la.l2_psm)
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -020055 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
Ville Tervob62f3282011-02-10 22:38:50 -030080 if (la.l2_cid)
Gustavo F. Padovan9e4425f2011-04-18 18:38:43 -030081 err = l2cap_add_scid(chan, la.l2_cid);
82 else
83 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
Ville Tervob62f3282011-02-10 22:38:50 -030084
Gustavo F. Padovan9e4425f2011-04-18 18:38:43 -030085 if (err < 0)
86 goto done;
87
88 if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
89 __le16_to_cpu(la.l2_psm) == 0x0003)
90 chan->sec_level = BT_SECURITY_SDP;
91
92 bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -030093
94 chan->state = BT_BOUND;
Gustavo F. Padovan9e4425f2011-04-18 18:38:43 -030095 sk->sk_state = BT_BOUND;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -020096
97done:
98 release_sock(sk);
99 return err;
100}
101
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200102static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
103{
104 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300105 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200106 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
Ville Tervoacd7d372011-02-10 22:38:49 -0300119 if (la.l2_cid && la.l2_psm)
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200120 return -EINVAL;
121
122 lock_sock(sk);
123
Gustavo F. Padovan715ec002011-05-02 17:13:55 -0300124 if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED
Ville Tervoacd7d372011-02-10 22:38:49 -0300125 && !(la.l2_psm || la.l2_cid)) {
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200126 err = -EINVAL;
127 goto done;
128 }
129
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300130 switch (chan->mode) {
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200131 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 */
Gustavo F. Padovan715ec002011-05-02 17:13:55 -0300166 if ((__le16_to_cpu(la.l2_psm) & 0x0101) != 0x0001 && !la.l2_cid &&
167 chan->chan_type != L2CAP_CHAN_RAW) {
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200168 err = -EINVAL;
169 goto done;
170 }
171
172 /* Set destination address and psm */
173 bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
Gustavo F. Padovanfe4128e2011-04-13 19:50:45 -0300174 chan->psm = la.l2_psm;
175 chan->dcid = la.l2_cid;
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200176
Gustavo F. Padovan77a74c72011-04-12 18:17:14 -0300177 err = l2cap_chan_connect(l2cap_pi(sk)->chan);
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200178 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
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200189static int l2cap_sock_listen(struct socket *sock, int backlog)
190{
191 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300192 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200193 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
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300205 switch (chan->mode) {
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200206 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
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200218 sk->sk_max_ack_backlog = backlog;
219 sk->sk_ack_backlog = 0;
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -0300220
221 chan->state = BT_LISTEN;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200222 sk->sk_state = BT_LISTEN;
223
224done:
225 release_sock(sk);
226 return err;
227}
228
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200229static 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
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200238 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);
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400244 while (1) {
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200245 set_current_state(TASK_INTERRUPTIBLE);
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200246
247 if (sk->sk_state != BT_LISTEN) {
248 err = -EBADFD;
249 break;
250 }
251
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400252 nsk = bt_accept_dequeue(sk, newsock);
253 if (nsk)
254 break;
255
256 if (!timeo) {
257 err = -EAGAIN;
258 break;
259 }
260
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200261 if (signal_pending(current)) {
262 err = sock_intr_errno(timeo);
263 break;
264 }
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400265
266 release_sock(sk);
267 timeo = schedule_timeout(timeo);
268 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200269 }
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400270 __set_current_state(TASK_RUNNING);
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200271 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
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200285static 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;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300289 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200290
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) {
Gustavo F. Padovanfe4128e2011-04-13 19:50:45 -0300297 la->l2_psm = chan->psm;
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200298 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
Gustavo F. Padovanfe4128e2011-04-13 19:50:45 -0300299 la->l2_cid = cpu_to_le16(chan->dcid);
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200300 } else {
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300301 la->l2_psm = chan->sport;
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200302 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
Gustavo F. Padovanfe4128e2011-04-13 19:50:45 -0300303 la->l2_cid = cpu_to_le16(chan->scid);
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200304 }
305
306 return 0;
307}
308
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200309static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
310{
311 struct sock *sk = sock->sk;
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300312 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200313 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:
Vasiliy Kulikove3fb5922011-02-10 20:59:42 +0300327 memset(&opts, 0, sizeof(opts));
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300328 opts.imtu = chan->imtu;
329 opts.omtu = chan->omtu;
330 opts.flush_to = chan->flush_to;
331 opts.mode = chan->mode;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -0300332 opts.fcs = chan->fcs;
333 opts.max_tx = chan->max_tx;
334 opts.txwin_size = (__u16)chan->tx_win;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200335
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:
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300343 switch (chan->sec_level) {
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200344 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
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300359 if (chan->role_switch)
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200360 opt |= L2CAP_LM_MASTER;
361
Andrei Emeltchenkoecf61bd2011-10-11 14:04:32 +0300362 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200363 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
Filip Palian8d03e972011-05-12 19:32:46 +0200377 memset(&cinfo, 0, sizeof(cinfo));
Gustavo F. Padovan8c1d7872011-04-13 20:23:55 -0300378 cinfo.hci_handle = chan->conn->hcon->handle;
379 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200380
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;
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300399 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200400 struct bt_security sec;
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700401 struct bt_power pwr;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200402 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:
Gustavo F. Padovan715ec002011-05-02 17:13:55 -0300419 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
420 chan->chan_type != L2CAP_CHAN_RAW) {
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200421 err = -EINVAL;
422 break;
423 }
424
Vinicius Costa Gomes8f360112011-07-08 18:31:46 -0300425 memset(&sec, 0, sizeof(sec));
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300426 sec.level = chan->sec_level;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200427
Vinicius Costa Gomes8f360112011-07-08 18:31:46 -0300428 if (sk->sk_state == BT_CONNECTED)
429 sec.key_size = chan->conn->hcon->enc_key_size;
430
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200431 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:
Andrei Emeltchenkod57b0e82011-10-11 14:04:31 +0300449 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
450 (u32 __user *) optval))
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200451 err = -EFAULT;
452
453 break;
454
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700455 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
Andrei Emeltchenko15770b12011-10-11 14:04:33 +0300462 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700463
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
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200470 default:
471 err = -ENOPROTOOPT;
472 break;
473 }
474
475 release_sock(sk);
476 return err;
477}
478
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200479static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
480{
481 struct sock *sk = sock->sk;
Gustavo F. Padovanb4450032011-04-12 18:15:09 -0300482 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200483 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
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300498 opts.imtu = chan->imtu;
499 opts.omtu = chan->omtu;
500 opts.flush_to = chan->flush_to;
501 opts.mode = chan->mode;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -0300502 opts.fcs = chan->fcs;
503 opts.max_tx = chan->max_tx;
504 opts.txwin_size = (__u16)chan->tx_win;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200505
506 len = min_t(unsigned int, sizeof(opts), optlen);
507 if (copy_from_user((char *) &opts, optval, len)) {
508 err = -EFAULT;
509 break;
510 }
511
512 if (opts.txwin_size > L2CAP_DEFAULT_TX_WINDOW) {
513 err = -EINVAL;
514 break;
515 }
516
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300517 chan->mode = opts.mode;
518 switch (chan->mode) {
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200519 case L2CAP_MODE_BASIC:
Gustavo F. Padovanc1360a12011-06-10 17:02:12 -0300520 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200521 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
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300532 chan->imtu = opts.imtu;
533 chan->omtu = opts.omtu;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -0300534 chan->fcs = opts.fcs;
535 chan->max_tx = opts.max_tx;
536 chan->tx_win = (__u8)opts.txwin_size;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200537 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)
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300546 chan->sec_level = BT_SECURITY_LOW;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200547 if (opt & L2CAP_LM_ENCRYPT)
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300548 chan->sec_level = BT_SECURITY_MEDIUM;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200549 if (opt & L2CAP_LM_SECURE)
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300550 chan->sec_level = BT_SECURITY_HIGH;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200551
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300552 chan->role_switch = (opt & L2CAP_LM_MASTER);
Andrei Emeltchenkoecf61bd2011-10-11 14:04:32 +0300553
554 if (opt & L2CAP_LM_RELIABLE)
555 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
556 else
557 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200558 break;
559
560 default:
561 err = -ENOPROTOOPT;
562 break;
563 }
564
565 release_sock(sk);
566 return err;
567}
568
569static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
570{
571 struct sock *sk = sock->sk;
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300572 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200573 struct bt_security sec;
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700574 struct bt_power pwr;
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300575 struct l2cap_conn *conn;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200576 int len, err = 0;
577 u32 opt;
578
579 BT_DBG("sk %p", sk);
580
581 if (level == SOL_L2CAP)
582 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
583
584 if (level != SOL_BLUETOOTH)
585 return -ENOPROTOOPT;
586
587 lock_sock(sk);
588
589 switch (optname) {
590 case BT_SECURITY:
Gustavo F. Padovan715ec002011-05-02 17:13:55 -0300591 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
592 chan->chan_type != L2CAP_CHAN_RAW) {
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200593 err = -EINVAL;
594 break;
595 }
596
597 sec.level = BT_SECURITY_LOW;
598
599 len = min_t(unsigned int, sizeof(sec), optlen);
600 if (copy_from_user((char *) &sec, optval, len)) {
601 err = -EFAULT;
602 break;
603 }
604
605 if (sec.level < BT_SECURITY_LOW ||
606 sec.level > BT_SECURITY_HIGH) {
607 err = -EINVAL;
608 break;
609 }
610
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300611 chan->sec_level = sec.level;
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300612
613 conn = chan->conn;
614 if (conn && chan->scid == L2CAP_CID_LE_DATA) {
615 if (!conn->hcon->out) {
616 err = -EINVAL;
617 break;
618 }
619
620 if (smp_conn_security(conn, sec.level))
621 break;
622
623 err = 0;
624 sk->sk_state = BT_CONFIG;
625 }
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200626 break;
627
628 case BT_DEFER_SETUP:
629 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
630 err = -EINVAL;
631 break;
632 }
633
634 if (get_user(opt, (u32 __user *) optval)) {
635 err = -EFAULT;
636 break;
637 }
638
639 bt_sk(sk)->defer_setup = opt;
640 break;
641
642 case BT_FLUSHABLE:
643 if (get_user(opt, (u32 __user *) optval)) {
644 err = -EFAULT;
645 break;
646 }
647
648 if (opt > BT_FLUSHABLE_ON) {
649 err = -EINVAL;
650 break;
651 }
652
653 if (opt == BT_FLUSHABLE_OFF) {
Gustavo F. Padovan8c1d7872011-04-13 20:23:55 -0300654 struct l2cap_conn *conn = chan->conn;
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300655 /* proceed further only when we have l2cap_conn and
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200656 No Flush support in the LM */
657 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
658 err = -EINVAL;
659 break;
660 }
661 }
662
Andrei Emeltchenkod57b0e82011-10-11 14:04:31 +0300663 if (opt)
664 set_bit(FLAG_FLUSHABLE, &chan->flags);
665 else
666 clear_bit(FLAG_FLUSHABLE, &chan->flags);
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200667 break;
668
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700669 case BT_POWER:
670 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
671 chan->chan_type != L2CAP_CHAN_RAW) {
672 err = -EINVAL;
673 break;
674 }
675
676 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
677
678 len = min_t(unsigned int, sizeof(pwr), optlen);
679 if (copy_from_user((char *) &pwr, optval, len)) {
680 err = -EFAULT;
681 break;
682 }
Andrei Emeltchenko15770b12011-10-11 14:04:33 +0300683
684 if (pwr.force_active)
685 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
686 else
687 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700688 break;
689
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200690 default:
691 err = -ENOPROTOOPT;
692 break;
693 }
694
695 release_sock(sk);
696 return err;
697}
698
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200699static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
700{
701 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300702 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200703 int err;
704
705 BT_DBG("sock %p, sk %p", sock, sk);
706
707 err = sock_error(sk);
708 if (err)
709 return err;
710
711 if (msg->msg_flags & MSG_OOB)
712 return -EOPNOTSUPP;
713
714 lock_sock(sk);
715
716 if (sk->sk_state != BT_CONNECTED) {
Gustavo F. Padovan9a91a042011-04-28 18:50:17 -0300717 release_sock(sk);
718 return -ENOTCONN;
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200719 }
720
Gustavo F. Padovan9a91a042011-04-28 18:50:17 -0300721 err = l2cap_chan_send(chan, msg, len);
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200722
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200723 release_sock(sk);
724 return err;
725}
726
Gustavo F. Padovan68983252011-02-04 03:02:31 -0200727static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
728{
729 struct sock *sk = sock->sk;
Mat Martineaue3281402011-07-07 09:39:02 -0700730 struct l2cap_pinfo *pi = l2cap_pi(sk);
731 int err;
Gustavo F. Padovan68983252011-02-04 03:02:31 -0200732
733 lock_sock(sk);
734
735 if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
Gustavo F. Padovan8c1d7872011-04-13 20:23:55 -0300736 sk->sk_state = BT_CONFIG;
737
Mat Martineaue3281402011-07-07 09:39:02 -0700738 __l2cap_connect_rsp_defer(pi->chan);
Gustavo F. Padovan68983252011-02-04 03:02:31 -0200739 release_sock(sk);
740 return 0;
741 }
742
743 release_sock(sk);
744
745 if (sock->type == SOCK_STREAM)
Mat Martineaue3281402011-07-07 09:39:02 -0700746 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
747 else
748 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
Gustavo F. Padovan68983252011-02-04 03:02:31 -0200749
Mat Martineaue3281402011-07-07 09:39:02 -0700750 if (pi->chan->mode != L2CAP_MODE_ERTM)
751 return err;
752
753 /* Attempt to put pending rx data in the socket buffer */
754
755 lock_sock(sk);
756
757 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
758 goto done;
759
760 if (pi->rx_busy_skb) {
761 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
762 pi->rx_busy_skb = NULL;
763 else
764 goto done;
765 }
766
767 /* Restore data flow when half of the receive buffer is
768 * available. This avoids resending large numbers of
769 * frames.
770 */
771 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
772 l2cap_chan_busy(pi->chan, 0);
773
774done:
775 release_sock(sk);
776 return err;
Gustavo F. Padovan68983252011-02-04 03:02:31 -0200777}
778
Gustavo F. Padovan05fc1572011-02-04 03:26:01 -0200779/* Kill socket (only if zapped and orphan)
780 * Must be called on unlocked socket.
781 */
Gustavo F. Padovanba3bd0e2011-05-16 18:23:24 -0300782static void l2cap_sock_kill(struct sock *sk)
Gustavo F. Padovan05fc1572011-02-04 03:26:01 -0200783{
784 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
785 return;
786
787 BT_DBG("sk %p state %d", sk, sk->sk_state);
788
789 /* Kill poor orphan */
Gustavo F. Padovan6ff5abb2011-04-25 15:10:41 -0300790
Gustavo F. Padovan23691d72011-04-27 18:26:32 -0300791 l2cap_chan_destroy(l2cap_pi(sk)->chan);
Gustavo F. Padovan05fc1572011-02-04 03:26:01 -0200792 sock_set_flag(sk, SOCK_DEAD);
793 sock_put(sk);
794}
795
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -0200796static int l2cap_sock_shutdown(struct socket *sock, int how)
797{
798 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300799 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -0200800 int err = 0;
801
802 BT_DBG("sock %p, sk %p", sock, sk);
803
804 if (!sk)
805 return 0;
806
807 lock_sock(sk);
808 if (!sk->sk_shutdown) {
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300809 if (chan->mode == L2CAP_MODE_ERTM)
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -0200810 err = __l2cap_wait_ack(sk);
811
812 sk->sk_shutdown = SHUTDOWN_MASK;
Gustavo F. Padovan0f852722011-05-04 19:42:50 -0300813 l2cap_chan_close(chan, 0);
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -0200814
815 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
816 err = bt_sock_wait_state(sk, BT_CLOSED,
817 sk->sk_lingertime);
818 }
819
820 if (!err && sk->sk_err)
821 err = -sk->sk_err;
822
823 release_sock(sk);
824 return err;
825}
826
Gustavo F. Padovan554f05b2011-02-04 02:36:42 -0200827static int l2cap_sock_release(struct socket *sock)
828{
829 struct sock *sk = sock->sk;
830 int err;
831
832 BT_DBG("sock %p, sk %p", sock, sk);
833
834 if (!sk)
835 return 0;
836
837 err = l2cap_sock_shutdown(sock, 2);
838
839 sock_orphan(sk);
840 l2cap_sock_kill(sk);
841 return err;
842}
843
Gustavo F. Padovan80808e42011-05-16 17:24:37 -0300844static struct l2cap_chan *l2cap_sock_new_connection_cb(void *data)
845{
846 struct sock *sk, *parent = data;
847
848 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
849 GFP_ATOMIC);
850 if (!sk)
851 return NULL;
852
853 l2cap_sock_init(sk, parent);
854
855 return l2cap_pi(sk)->chan;
856}
857
Gustavo F. Padovan23070492011-05-16 17:57:22 -0300858static int l2cap_sock_recv_cb(void *data, struct sk_buff *skb)
859{
Mat Martineaue3281402011-07-07 09:39:02 -0700860 int err;
Gustavo F. Padovan23070492011-05-16 17:57:22 -0300861 struct sock *sk = data;
Mat Martineaue3281402011-07-07 09:39:02 -0700862 struct l2cap_pinfo *pi = l2cap_pi(sk);
Gustavo F. Padovan23070492011-05-16 17:57:22 -0300863
Mat Martineaue3281402011-07-07 09:39:02 -0700864 if (pi->rx_busy_skb)
865 return -ENOMEM;
866
867 err = sock_queue_rcv_skb(sk, skb);
868
869 /* For ERTM, handle one skb that doesn't fit into the recv
870 * buffer. This is important to do because the data frames
871 * have already been acked, so the skb cannot be discarded.
872 *
873 * Notify the l2cap core that the buffer is full, so the
874 * LOCAL_BUSY state is entered and no more frames are
875 * acked and reassembled until there is buffer space
876 * available.
877 */
878 if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
879 pi->rx_busy_skb = skb;
880 l2cap_chan_busy(pi->chan, 1);
881 err = 0;
882 }
883
884 return err;
Gustavo F. Padovan23070492011-05-16 17:57:22 -0300885}
886
Gustavo F. Padovanba3bd0e2011-05-16 18:23:24 -0300887static void l2cap_sock_close_cb(void *data)
888{
889 struct sock *sk = data;
890
891 l2cap_sock_kill(sk);
892}
893
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -0300894static void l2cap_sock_state_change_cb(void *data, int state)
895{
896 struct sock *sk = data;
897
898 sk->sk_state = state;
899}
900
Gustavo F. Padovan80808e42011-05-16 17:24:37 -0300901static struct l2cap_ops l2cap_chan_ops = {
902 .name = "L2CAP Socket Interface",
903 .new_connection = l2cap_sock_new_connection_cb,
Gustavo F. Padovan23070492011-05-16 17:57:22 -0300904 .recv = l2cap_sock_recv_cb,
Gustavo F. Padovanba3bd0e2011-05-16 18:23:24 -0300905 .close = l2cap_sock_close_cb,
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -0300906 .state_change = l2cap_sock_state_change_cb,
Gustavo F. Padovan80808e42011-05-16 17:24:37 -0300907};
908
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200909static void l2cap_sock_destruct(struct sock *sk)
910{
911 BT_DBG("sk %p", sk);
912
Mat Martineaue3281402011-07-07 09:39:02 -0700913 if (l2cap_pi(sk)->rx_busy_skb) {
914 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
915 l2cap_pi(sk)->rx_busy_skb = NULL;
916 }
917
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200918 skb_queue_purge(&sk->sk_receive_queue);
919 skb_queue_purge(&sk->sk_write_queue);
920}
921
Gustavo F. Padovan80808e42011-05-16 17:24:37 -0300922static void l2cap_sock_init(struct sock *sk, struct sock *parent)
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200923{
924 struct l2cap_pinfo *pi = l2cap_pi(sk);
Gustavo F. Padovanb4450032011-04-12 18:15:09 -0300925 struct l2cap_chan *chan = pi->chan;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200926
927 BT_DBG("sk %p", sk);
928
929 if (parent) {
Gustavo F. Padovanb4450032011-04-12 18:15:09 -0300930 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
931
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200932 sk->sk_type = parent->sk_type;
933 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
934
Gustavo F. Padovan715ec002011-05-02 17:13:55 -0300935 chan->chan_type = pchan->chan_type;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300936 chan->imtu = pchan->imtu;
937 chan->omtu = pchan->omtu;
Gustavo F. Padovanb4450032011-04-12 18:15:09 -0300938 chan->conf_state = pchan->conf_state;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300939 chan->mode = pchan->mode;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -0300940 chan->fcs = pchan->fcs;
941 chan->max_tx = pchan->max_tx;
942 chan->tx_win = pchan->tx_win;
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300943 chan->sec_level = pchan->sec_level;
944 chan->role_switch = pchan->role_switch;
Andrei Emeltchenkod57b0e82011-10-11 14:04:31 +0300945 chan->flags = pchan->flags;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200946 } else {
Gustavo F. Padovan715ec002011-05-02 17:13:55 -0300947
948 switch (sk->sk_type) {
949 case SOCK_RAW:
950 chan->chan_type = L2CAP_CHAN_RAW;
951 break;
952 case SOCK_DGRAM:
953 chan->chan_type = L2CAP_CHAN_CONN_LESS;
954 break;
955 case SOCK_SEQPACKET:
956 case SOCK_STREAM:
957 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
958 break;
959 }
960
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300961 chan->imtu = L2CAP_DEFAULT_MTU;
962 chan->omtu = 0;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200963 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300964 chan->mode = L2CAP_MODE_ERTM;
Gustavo F. Padovanc1360a12011-06-10 17:02:12 -0300965 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200966 } else {
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300967 chan->mode = L2CAP_MODE_BASIC;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200968 }
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -0300969 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
970 chan->fcs = L2CAP_FCS_CRC16;
971 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300972 chan->sec_level = BT_SECURITY_LOW;
973 chan->role_switch = 0;
Andrei Emeltchenkod57b0e82011-10-11 14:04:31 +0300974 chan->flags = 0;
Andrei Emeltchenko15770b12011-10-11 14:04:33 +0300975 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200976 }
977
978 /* Default config options */
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300979 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
Gustavo F. Padovan80808e42011-05-16 17:24:37 -0300980
981 chan->data = sk;
982 chan->ops = &l2cap_chan_ops;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200983}
984
985static struct proto l2cap_proto = {
986 .name = "L2CAP",
987 .owner = THIS_MODULE,
988 .obj_size = sizeof(struct l2cap_pinfo)
989};
990
Gustavo F. Padovan80808e42011-05-16 17:24:37 -0300991static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200992{
993 struct sock *sk;
Gustavo F. Padovandc50a062011-05-16 16:42:01 -0300994 struct l2cap_chan *chan;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -0200995
996 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
997 if (!sk)
998 return NULL;
999
1000 sock_init_data(sock, sk);
1001 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1002
1003 sk->sk_destruct = l2cap_sock_destruct;
Chen Ganir6be6b112011-07-28 15:42:09 +03001004 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001005
1006 sock_reset_flag(sk, SOCK_ZAPPED);
1007
1008 sk->sk_protocol = proto;
1009 sk->sk_state = BT_OPEN;
1010
Gustavo F. Padovandc50a062011-05-16 16:42:01 -03001011 chan = l2cap_chan_create(sk);
1012 if (!chan) {
1013 l2cap_sock_kill(sk);
1014 return NULL;
1015 }
1016
1017 l2cap_pi(sk)->chan = chan;
1018
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001019 return sk;
1020}
1021
1022static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1023 int kern)
1024{
1025 struct sock *sk;
1026
1027 BT_DBG("sock %p", sock);
1028
1029 sock->state = SS_UNCONNECTED;
1030
1031 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1032 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1033 return -ESOCKTNOSUPPORT;
1034
1035 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1036 return -EPERM;
1037
1038 sock->ops = &l2cap_sock_ops;
1039
1040 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1041 if (!sk)
1042 return -ENOMEM;
1043
1044 l2cap_sock_init(sk, NULL);
1045 return 0;
1046}
1047
Gustavo F. Padovancf2f90f2011-04-27 18:40:39 -03001048static const struct proto_ops l2cap_sock_ops = {
Gustavo F. Padovan65390582011-02-04 02:33:56 -02001049 .family = PF_BLUETOOTH,
1050 .owner = THIS_MODULE,
1051 .release = l2cap_sock_release,
1052 .bind = l2cap_sock_bind,
1053 .connect = l2cap_sock_connect,
1054 .listen = l2cap_sock_listen,
1055 .accept = l2cap_sock_accept,
1056 .getname = l2cap_sock_getname,
1057 .sendmsg = l2cap_sock_sendmsg,
1058 .recvmsg = l2cap_sock_recvmsg,
1059 .poll = bt_sock_poll,
1060 .ioctl = bt_sock_ioctl,
1061 .mmap = sock_no_mmap,
1062 .socketpair = sock_no_socketpair,
1063 .shutdown = l2cap_sock_shutdown,
1064 .setsockopt = l2cap_sock_setsockopt,
1065 .getsockopt = l2cap_sock_getsockopt
1066};
1067
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001068static const struct net_proto_family l2cap_sock_family_ops = {
1069 .family = PF_BLUETOOTH,
1070 .owner = THIS_MODULE,
1071 .create = l2cap_sock_create,
1072};
1073
1074int __init l2cap_init_sockets(void)
1075{
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001076 int err;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001077
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001078 err = proto_register(&l2cap_proto, 0);
1079 if (err < 0)
1080 return err;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001081
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001082 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1083 if (err < 0)
1084 goto error;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001085
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001086 BT_INFO("L2CAP socket layer initialized");
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001087
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001088 return 0;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001089
1090error:
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001091 BT_ERR("L2CAP socket registration failed");
1092 proto_unregister(&l2cap_proto);
1093 return err;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001094}
1095
1096void l2cap_cleanup_sockets(void)
1097{
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001098 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1099 BT_ERR("L2CAP socket unregistration failed");
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001100
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001101 proto_unregister(&l2cap_proto);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001102}