blob: 04abd26a346684d87010bae7f5f606bf81c47474 [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.
Gustavo F. Padovan590051d2011-12-18 13:39:33 -02006 Copyright (C) 2011 ProFUSION Embedded Systems
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02007
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
Johan Hedberg91497612013-12-02 11:20:20 +020030#include <linux/module.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040031#include <linux/export.h>
Paul Moore6230c9b2011-10-07 09:40:59 +000032
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -020033#include <net/bluetooth/bluetooth.h>
Gustavo F. Padovan33575df2011-02-04 02:48:48 -020034#include <net/bluetooth/hci_core.h>
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -020035#include <net/bluetooth/l2cap.h>
Marcel Holtmannac4b7232013-10-10 14:54:16 -070036
37#include "smp.h"
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -020038
Johan Hedberg91497612013-12-02 11:20:20 +020039bool enable_lecoc;
40
Masatake YAMATO5b28d952012-07-26 01:29:25 +090041static struct bt_sock_list l2cap_sk_list = {
42 .lock = __RW_LOCK_UNLOCKED(l2cap_sk_list.lock)
43};
44
Gustavo F. Padovancf2f90f2011-04-27 18:40:39 -030045static const struct proto_ops l2cap_sock_ops;
Gustavo F. Padovan80808e42011-05-16 17:24:37 -030046static void l2cap_sock_init(struct sock *sk, struct sock *parent);
Gustavo Padovan2d792812012-10-06 10:07:01 +010047static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
48 int proto, gfp_t prio);
Gustavo F. Padovancf2f90f2011-04-27 18:40:39 -030049
David Herrmannb3916db2013-04-05 14:57:34 +020050bool l2cap_is_socket(struct socket *sock)
51{
52 return sock && sock->ops == &l2cap_sock_ops;
53}
54EXPORT_SYMBOL(l2cap_is_socket);
55
Johan Hedberg49460962013-10-08 13:55:46 +020056static int l2cap_validate_bredr_psm(u16 psm)
57{
58 /* PSM must be odd and lsb of upper byte must be 0 */
59 if ((psm & 0x0101) != 0x0001)
60 return -EINVAL;
61
62 /* Restrict usage of well-known PSMs */
63 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE))
64 return -EACCES;
65
66 return 0;
67}
68
69static int l2cap_validate_le_psm(u16 psm)
70{
71 /* Valid LE_PSM ranges are defined only until 0x00ff */
72 if (psm > 0x00ff)
73 return -EINVAL;
74
75 /* Restrict fixed, SIG assigned PSM values to CAP_NET_BIND_SERVICE */
76 if (psm <= 0x007f && !capable(CAP_NET_BIND_SERVICE))
77 return -EACCES;
78
79 return 0;
80}
81
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -020082static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
83{
84 struct sock *sk = sock->sk;
Gustavo F. Padovan43434782011-04-12 18:31:57 -030085 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -020086 struct sockaddr_l2 la;
87 int len, err = 0;
88
89 BT_DBG("sk %p", sk);
90
91 if (!addr || addr->sa_family != AF_BLUETOOTH)
92 return -EINVAL;
93
94 memset(&la, 0, sizeof(la));
95 len = min_t(unsigned int, sizeof(la), alen);
96 memcpy(&la, addr, len);
97
Ville Tervob62f3282011-02-10 22:38:50 -030098 if (la.l2_cid && la.l2_psm)
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -020099 return -EINVAL;
100
Johan Hedberg80c1a2e2013-10-14 21:17:52 +0300101 if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
102 return -EINVAL;
103
Johan Hedberg21626e62014-01-24 10:35:41 +0200104 if (la.l2_cid) {
105 /* When the socket gets created it defaults to
106 * CHAN_CONN_ORIENTED, so we need to overwrite the
107 * default here.
108 */
109 chan->chan_type = L2CAP_CHAN_FIXED;
110 chan->omtu = L2CAP_DEFAULT_MTU;
111 }
112
Johan Hedbergbfe46552013-10-16 17:13:26 +0300113 if (bdaddr_type_is_le(la.l2_bdaddr_type)) {
Johan Hedberg91497612013-12-02 11:20:20 +0200114 if (!enable_lecoc && la.l2_psm)
Johan Hedbergbfe46552013-10-16 17:13:26 +0300115 return -EINVAL;
116 /* We only allow ATT user space socket */
Johan Hedberg91497612013-12-02 11:20:20 +0200117 if (la.l2_cid &&
118 la.l2_cid != __constant_cpu_to_le16(L2CAP_CID_ATT))
Johan Hedbergbfe46552013-10-16 17:13:26 +0300119 return -EINVAL;
120 }
121
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200122 lock_sock(sk);
123
124 if (sk->sk_state != BT_OPEN) {
125 err = -EBADFD;
126 goto done;
127 }
128
129 if (la.l2_psm) {
130 __u16 psm = __le16_to_cpu(la.l2_psm);
131
Johan Hedberg49460962013-10-08 13:55:46 +0200132 if (la.l2_bdaddr_type == BDADDR_BREDR)
133 err = l2cap_validate_bredr_psm(psm);
134 else
135 err = l2cap_validate_le_psm(psm);
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200136
Johan Hedberg49460962013-10-08 13:55:46 +0200137 if (err)
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200138 goto done;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200139 }
140
Ville Tervob62f3282011-02-10 22:38:50 -0300141 if (la.l2_cid)
Santosh Nayak6e4aff12012-03-01 22:46:36 +0530142 err = l2cap_add_scid(chan, __le16_to_cpu(la.l2_cid));
Gustavo F. Padovan9e4425f2011-04-18 18:38:43 -0300143 else
144 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
Ville Tervob62f3282011-02-10 22:38:50 -0300145
Gustavo F. Padovan9e4425f2011-04-18 18:38:43 -0300146 if (err < 0)
147 goto done;
148
Marcel Holtmann6a974b52013-10-12 07:19:31 -0700149 switch (chan->chan_type) {
Marcel Holtmann3124b842013-10-12 07:19:32 -0700150 case L2CAP_CHAN_CONN_LESS:
151 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_3DSP)
152 chan->sec_level = BT_SECURITY_SDP;
153 break;
Marcel Holtmann6a974b52013-10-12 07:19:31 -0700154 case L2CAP_CHAN_CONN_ORIENTED:
155 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_SDP ||
156 __le16_to_cpu(la.l2_psm) == L2CAP_PSM_RFCOMM)
157 chan->sec_level = BT_SECURITY_SDP;
158 break;
Johan Hedbergcb6ca8e2014-01-06 18:27:02 +0200159 case L2CAP_CHAN_RAW:
160 chan->sec_level = BT_SECURITY_SDP;
161 break;
Marcel Holtmann6a974b52013-10-12 07:19:31 -0700162 }
Gustavo F. Padovan9e4425f2011-04-18 18:38:43 -0300163
Marcel Holtmann7eafc592013-10-13 08:12:47 -0700164 bacpy(&chan->src, &la.l2_bdaddr);
Marcel Holtmann4f1654e2013-10-13 08:50:41 -0700165 chan->src_type = la.l2_bdaddr_type;
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -0300166
Johan Hedberg38319712013-05-17 12:49:23 +0300167 if (chan->psm && bdaddr_type_is_le(chan->src_type))
Johan Hedberg0ce43ce2013-12-05 14:55:33 +0200168 chan->mode = L2CAP_MODE_LE_FLOWCTL;
Johan Hedberg38319712013-05-17 12:49:23 +0300169
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -0300170 chan->state = BT_BOUND;
Gustavo F. Padovan9e4425f2011-04-18 18:38:43 -0300171 sk->sk_state = BT_BOUND;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200172
173done:
174 release_sock(sk);
175 return err;
176}
177
Gustavo Padovan2d792812012-10-06 10:07:01 +0100178static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr,
179 int alen, int flags)
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200180{
181 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300182 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200183 struct sockaddr_l2 la;
184 int len, err = 0;
185
186 BT_DBG("sk %p", sk);
187
188 if (!addr || alen < sizeof(addr->sa_family) ||
189 addr->sa_family != AF_BLUETOOTH)
190 return -EINVAL;
191
192 memset(&la, 0, sizeof(la));
193 len = min_t(unsigned int, sizeof(la), alen);
194 memcpy(&la, addr, len);
195
Ville Tervoacd7d372011-02-10 22:38:49 -0300196 if (la.l2_cid && la.l2_psm)
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200197 return -EINVAL;
198
Johan Hedberg80c1a2e2013-10-14 21:17:52 +0300199 if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
200 return -EINVAL;
201
Johan Hedbergeb622492013-10-18 11:49:25 +0300202 /* Check that the socket wasn't bound to something that
203 * conflicts with the address given to connect(). If chan->src
204 * is BDADDR_ANY it means bind() was never used, in which case
205 * chan->src_type and la.l2_bdaddr_type do not need to match.
206 */
207 if (chan->src_type == BDADDR_BREDR && bacmp(&chan->src, BDADDR_ANY) &&
208 bdaddr_type_is_le(la.l2_bdaddr_type)) {
209 /* Old user space versions will try to incorrectly bind
210 * the ATT socket using BDADDR_BREDR. We need to accept
211 * this and fix up the source address type only when
212 * both the source CID and destination CID indicate
213 * ATT. Anything else is an invalid combination.
214 */
215 if (chan->scid != L2CAP_CID_ATT ||
216 la.l2_cid != __constant_cpu_to_le16(L2CAP_CID_ATT))
217 return -EINVAL;
218
219 /* We don't have the hdev available here to make a
220 * better decision on random vs public, but since all
221 * user space versions that exhibit this issue anyway do
222 * not support random local addresses assuming public
223 * here is good enough.
224 */
225 chan->src_type = BDADDR_LE_PUBLIC;
226 }
Johan Hedberg1f209382013-10-14 21:17:53 +0300227
228 if (chan->src_type != BDADDR_BREDR && la.l2_bdaddr_type == BDADDR_BREDR)
229 return -EINVAL;
230
Johan Hedbergbfe46552013-10-16 17:13:26 +0300231 if (bdaddr_type_is_le(la.l2_bdaddr_type)) {
Johan Hedberg91497612013-12-02 11:20:20 +0200232 if (!enable_lecoc && la.l2_psm)
Johan Hedbergbfe46552013-10-16 17:13:26 +0300233 return -EINVAL;
234 /* We only allow ATT user space socket */
Johan Hedberg91497612013-12-02 11:20:20 +0200235 if (la.l2_cid &&
236 la.l2_cid != __constant_cpu_to_le16(L2CAP_CID_ATT))
Johan Hedbergbfe46552013-10-16 17:13:26 +0300237 return -EINVAL;
238 }
239
Johan Hedberg38319712013-05-17 12:49:23 +0300240 if (chan->psm && bdaddr_type_is_le(chan->src_type))
Johan Hedberg0ce43ce2013-12-05 14:55:33 +0200241 chan->mode = L2CAP_MODE_LE_FLOWCTL;
Johan Hedberg38319712013-05-17 12:49:23 +0300242
Santosh Nayak6e4aff12012-03-01 22:46:36 +0530243 err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),
Andre Guedes8e9f9892012-04-24 21:02:55 -0300244 &la.l2_bdaddr, la.l2_bdaddr_type);
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200245 if (err)
Andrei Emeltchenkob3fb6112012-02-22 17:11:57 +0200246 return err;
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200247
Andrei Emeltchenko6be36552012-02-22 17:11:56 +0200248 lock_sock(sk);
249
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200250 err = bt_sock_wait_state(sk, BT_CONNECTED,
Gustavo Padovan2d792812012-10-06 10:07:01 +0100251 sock_sndtimeo(sk, flags & O_NONBLOCK));
Andrei Emeltchenkob3fb6112012-02-22 17:11:57 +0200252
253 release_sock(sk);
254
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200255 return err;
256}
257
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200258static int l2cap_sock_listen(struct socket *sock, int backlog)
259{
260 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300261 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200262 int err = 0;
263
264 BT_DBG("sk %p backlog %d", sk, backlog);
265
266 lock_sock(sk);
267
Marcel Holtmann6b3af732012-04-19 13:43:51 +0200268 if (sk->sk_state != BT_BOUND) {
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200269 err = -EBADFD;
270 goto done;
271 }
272
Marcel Holtmann6b3af732012-04-19 13:43:51 +0200273 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM) {
274 err = -EINVAL;
275 goto done;
276 }
277
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300278 switch (chan->mode) {
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200279 case L2CAP_MODE_BASIC:
Johan Hedberg38319712013-05-17 12:49:23 +0300280 case L2CAP_MODE_LE_FLOWCTL:
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200281 break;
282 case L2CAP_MODE_ERTM:
283 case L2CAP_MODE_STREAMING:
284 if (!disable_ertm)
285 break;
286 /* fall through */
287 default:
288 err = -ENOTSUPP;
289 goto done;
290 }
291
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200292 sk->sk_max_ack_backlog = backlog;
293 sk->sk_ack_backlog = 0;
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -0300294
295 chan->state = BT_LISTEN;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200296 sk->sk_state = BT_LISTEN;
297
298done:
299 release_sock(sk);
300 return err;
301}
302
Gustavo Padovan2d792812012-10-06 10:07:01 +0100303static int l2cap_sock_accept(struct socket *sock, struct socket *newsock,
304 int flags)
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200305{
306 DECLARE_WAITQUEUE(wait, current);
307 struct sock *sk = sock->sk, *nsk;
308 long timeo;
309 int err = 0;
310
311 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
312
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200313 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
314
315 BT_DBG("sk %p timeo %ld", sk, timeo);
316
317 /* Wait for an incoming connection. (wake-one). */
318 add_wait_queue_exclusive(sk_sleep(sk), &wait);
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400319 while (1) {
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200320 set_current_state(TASK_INTERRUPTIBLE);
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200321
322 if (sk->sk_state != BT_LISTEN) {
323 err = -EBADFD;
324 break;
325 }
326
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400327 nsk = bt_accept_dequeue(sk, newsock);
328 if (nsk)
329 break;
330
331 if (!timeo) {
332 err = -EAGAIN;
333 break;
334 }
335
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200336 if (signal_pending(current)) {
337 err = sock_intr_errno(timeo);
338 break;
339 }
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400340
341 release_sock(sk);
342 timeo = schedule_timeout(timeo);
343 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200344 }
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400345 __set_current_state(TASK_RUNNING);
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200346 remove_wait_queue(sk_sleep(sk), &wait);
347
348 if (err)
349 goto done;
350
351 newsock->state = SS_CONNECTED;
352
353 BT_DBG("new socket %p", nsk);
354
355done:
356 release_sock(sk);
357 return err;
358}
359
Gustavo Padovan2d792812012-10-06 10:07:01 +0100360static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr,
361 int *len, int peer)
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200362{
363 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
364 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300365 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200366
367 BT_DBG("sock %p, sk %p", sock, sk);
368
Mathias Krause792039c2012-08-15 11:31:51 +0000369 memset(la, 0, sizeof(struct sockaddr_l2));
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200370 addr->sa_family = AF_BLUETOOTH;
371 *len = sizeof(struct sockaddr_l2);
372
373 if (peer) {
Gustavo F. Padovanfe4128e2011-04-13 19:50:45 -0300374 la->l2_psm = chan->psm;
Marcel Holtmann7eafc592013-10-13 08:12:47 -0700375 bacpy(&la->l2_bdaddr, &chan->dst);
Gustavo F. Padovanfe4128e2011-04-13 19:50:45 -0300376 la->l2_cid = cpu_to_le16(chan->dcid);
Marcel Holtmann4f1654e2013-10-13 08:50:41 -0700377 la->l2_bdaddr_type = chan->dst_type;
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200378 } else {
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300379 la->l2_psm = chan->sport;
Marcel Holtmann7eafc592013-10-13 08:12:47 -0700380 bacpy(&la->l2_bdaddr, &chan->src);
Gustavo F. Padovanfe4128e2011-04-13 19:50:45 -0300381 la->l2_cid = cpu_to_le16(chan->scid);
Marcel Holtmann4f1654e2013-10-13 08:50:41 -0700382 la->l2_bdaddr_type = chan->src_type;
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200383 }
384
385 return 0;
386}
387
Gustavo Padovan2d792812012-10-06 10:07:01 +0100388static int l2cap_sock_getsockopt_old(struct socket *sock, int optname,
389 char __user *optval, int __user *optlen)
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200390{
391 struct sock *sk = sock->sk;
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300392 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200393 struct l2cap_options opts;
394 struct l2cap_conninfo cinfo;
395 int len, err = 0;
396 u32 opt;
397
398 BT_DBG("sk %p", sk);
399
400 if (get_user(len, optlen))
401 return -EFAULT;
402
403 lock_sock(sk);
404
405 switch (optname) {
406 case L2CAP_OPTIONS:
Johan Hedberg64b4f8d2013-12-02 16:02:03 +0200407 /* LE sockets should use BT_SNDMTU/BT_RCVMTU, but since
408 * legacy ATT code depends on getsockopt for
409 * L2CAP_OPTIONS we need to let this pass.
410 */
411 if (bdaddr_type_is_le(chan->src_type) &&
412 chan->scid != L2CAP_CID_ATT) {
413 err = -EINVAL;
414 break;
415 }
416
Vasiliy Kulikove3fb5922011-02-10 20:59:42 +0300417 memset(&opts, 0, sizeof(opts));
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300418 opts.imtu = chan->imtu;
419 opts.omtu = chan->omtu;
420 opts.flush_to = chan->flush_to;
421 opts.mode = chan->mode;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -0300422 opts.fcs = chan->fcs;
423 opts.max_tx = chan->max_tx;
Andrei Emeltchenko6327eb92011-10-11 13:37:42 +0300424 opts.txwin_size = chan->tx_win;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200425
426 len = min_t(unsigned int, len, sizeof(opts));
427 if (copy_to_user(optval, (char *) &opts, len))
428 err = -EFAULT;
429
430 break;
431
432 case L2CAP_LM:
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300433 switch (chan->sec_level) {
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200434 case BT_SECURITY_LOW:
435 opt = L2CAP_LM_AUTH;
436 break;
437 case BT_SECURITY_MEDIUM:
438 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
439 break;
440 case BT_SECURITY_HIGH:
441 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
Gustavo Padovan2d792812012-10-06 10:07:01 +0100442 L2CAP_LM_SECURE;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200443 break;
Marcel Holtmann7d513e92014-01-15 22:37:40 -0800444 case BT_SECURITY_FIPS:
445 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
446 L2CAP_LM_SECURE | L2CAP_LM_FIPS;
447 break;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200448 default:
449 opt = 0;
450 break;
451 }
452
Andrei Emeltchenko43bd0f32011-10-11 14:04:34 +0300453 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200454 opt |= L2CAP_LM_MASTER;
455
Andrei Emeltchenkoecf61bd2011-10-11 14:04:32 +0300456 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200457 opt |= L2CAP_LM_RELIABLE;
458
459 if (put_user(opt, (u32 __user *) optval))
460 err = -EFAULT;
Marcel Holtmann7d513e92014-01-15 22:37:40 -0800461
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200462 break;
463
464 case L2CAP_CONNINFO:
465 if (sk->sk_state != BT_CONNECTED &&
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300466 !(sk->sk_state == BT_CONNECT2 &&
467 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200468 err = -ENOTCONN;
469 break;
470 }
471
Filip Palian8d03e972011-05-12 19:32:46 +0200472 memset(&cinfo, 0, sizeof(cinfo));
Gustavo F. Padovan8c1d7872011-04-13 20:23:55 -0300473 cinfo.hci_handle = chan->conn->hcon->handle;
474 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200475
476 len = min_t(unsigned int, len, sizeof(cinfo));
477 if (copy_to_user(optval, (char *) &cinfo, len))
478 err = -EFAULT;
479
480 break;
481
482 default:
483 err = -ENOPROTOOPT;
484 break;
485 }
486
487 release_sock(sk);
488 return err;
489}
490
Gustavo Padovan2d792812012-10-06 10:07:01 +0100491static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname,
492 char __user *optval, int __user *optlen)
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200493{
494 struct sock *sk = sock->sk;
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300495 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200496 struct bt_security sec;
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700497 struct bt_power pwr;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200498 int len, err = 0;
499
500 BT_DBG("sk %p", sk);
501
502 if (level == SOL_L2CAP)
503 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
504
505 if (level != SOL_BLUETOOTH)
506 return -ENOPROTOOPT;
507
508 if (get_user(len, optlen))
509 return -EFAULT;
510
511 lock_sock(sk);
512
513 switch (optname) {
514 case BT_SECURITY:
Gustavo F. Padovan715ec002011-05-02 17:13:55 -0300515 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
Gustavo Padovan2d792812012-10-06 10:07:01 +0100516 chan->chan_type != L2CAP_CHAN_RAW) {
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200517 err = -EINVAL;
518 break;
519 }
520
Vinicius Costa Gomes8f360112011-07-08 18:31:46 -0300521 memset(&sec, 0, sizeof(sec));
Andrei Emeltchenko85e34362012-10-05 16:56:54 +0300522 if (chan->conn) {
Gustavo Padovanc6585a42012-05-07 03:07:26 -0300523 sec.level = chan->conn->hcon->sec_level;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200524
Andrei Emeltchenko85e34362012-10-05 16:56:54 +0300525 if (sk->sk_state == BT_CONNECTED)
526 sec.key_size = chan->conn->hcon->enc_key_size;
527 } else {
528 sec.level = chan->sec_level;
529 }
Vinicius Costa Gomes8f360112011-07-08 18:31:46 -0300530
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200531 len = min_t(unsigned int, len, sizeof(sec));
532 if (copy_to_user(optval, (char *) &sec, len))
533 err = -EFAULT;
534
535 break;
536
537 case BT_DEFER_SETUP:
538 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
539 err = -EINVAL;
540 break;
541 }
542
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300543 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
544 (u32 __user *) optval))
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200545 err = -EFAULT;
546
547 break;
548
549 case BT_FLUSHABLE:
Andrei Emeltchenkod57b0e82011-10-11 14:04:31 +0300550 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
Gustavo Padovan2d792812012-10-06 10:07:01 +0100551 (u32 __user *) optval))
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200552 err = -EFAULT;
553
554 break;
555
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700556 case BT_POWER:
557 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
Gustavo Padovan2d792812012-10-06 10:07:01 +0100558 && sk->sk_type != SOCK_RAW) {
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700559 err = -EINVAL;
560 break;
561 }
562
Andrei Emeltchenko15770b12011-10-11 14:04:33 +0300563 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700564
565 len = min_t(unsigned int, len, sizeof(pwr));
566 if (copy_to_user(optval, (char *) &pwr, len))
567 err = -EFAULT;
568
569 break;
570
Mat Martineau2ea66482011-11-02 16:18:30 -0700571 case BT_CHANNEL_POLICY:
Mat Martineau2ea66482011-11-02 16:18:30 -0700572 if (put_user(chan->chan_policy, (u32 __user *) optval))
573 err = -EFAULT;
574 break;
575
Johan Hedberg1f435422013-12-02 16:34:18 +0200576 case BT_SNDMTU:
577 if (!enable_lecoc) {
578 err = -EPROTONOSUPPORT;
579 break;
580 }
581
582 if (!bdaddr_type_is_le(chan->src_type)) {
583 err = -EINVAL;
584 break;
585 }
586
587 if (sk->sk_state != BT_CONNECTED) {
588 err = -ENOTCONN;
589 break;
590 }
591
592 if (put_user(chan->omtu, (u16 __user *) optval))
593 err = -EFAULT;
594 break;
595
596 case BT_RCVMTU:
597 if (!enable_lecoc) {
598 err = -EPROTONOSUPPORT;
599 break;
600 }
601
602 if (!bdaddr_type_is_le(chan->src_type)) {
603 err = -EINVAL;
604 break;
605 }
606
607 if (put_user(chan->imtu, (u16 __user *) optval))
608 err = -EFAULT;
609 break;
610
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200611 default:
612 err = -ENOPROTOOPT;
613 break;
614 }
615
616 release_sock(sk);
617 return err;
618}
619
Andre Guedes682877c2012-05-31 17:01:34 -0300620static bool l2cap_valid_mtu(struct l2cap_chan *chan, u16 mtu)
621{
622 switch (chan->scid) {
Johan Hedberg073d1cf2013-04-29 19:35:35 +0300623 case L2CAP_CID_ATT:
Andre Guedes8c3a4f02012-05-31 17:01:35 -0300624 if (mtu < L2CAP_LE_MIN_MTU)
Andre Guedes682877c2012-05-31 17:01:34 -0300625 return false;
626 break;
627
628 default:
629 if (mtu < L2CAP_DEFAULT_MIN_MTU)
630 return false;
631 }
632
633 return true;
634}
635
Gustavo Padovan2d792812012-10-06 10:07:01 +0100636static int l2cap_sock_setsockopt_old(struct socket *sock, int optname,
637 char __user *optval, unsigned int optlen)
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200638{
639 struct sock *sk = sock->sk;
Gustavo F. Padovanb4450032011-04-12 18:15:09 -0300640 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200641 struct l2cap_options opts;
642 int len, err = 0;
643 u32 opt;
644
645 BT_DBG("sk %p", sk);
646
647 lock_sock(sk);
648
649 switch (optname) {
650 case L2CAP_OPTIONS:
Johan Hedberg64b4f8d2013-12-02 16:02:03 +0200651 if (bdaddr_type_is_le(chan->src_type)) {
652 err = -EINVAL;
653 break;
654 }
655
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200656 if (sk->sk_state == BT_CONNECTED) {
657 err = -EINVAL;
658 break;
659 }
660
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300661 opts.imtu = chan->imtu;
662 opts.omtu = chan->omtu;
663 opts.flush_to = chan->flush_to;
664 opts.mode = chan->mode;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -0300665 opts.fcs = chan->fcs;
666 opts.max_tx = chan->max_tx;
Andrei Emeltchenko6327eb92011-10-11 13:37:42 +0300667 opts.txwin_size = chan->tx_win;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200668
669 len = min_t(unsigned int, sizeof(opts), optlen);
670 if (copy_from_user((char *) &opts, optval, len)) {
671 err = -EFAULT;
672 break;
673 }
674
Andrei Emeltchenko6327eb92011-10-11 13:37:42 +0300675 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200676 err = -EINVAL;
677 break;
678 }
679
Andre Guedes682877c2012-05-31 17:01:34 -0300680 if (!l2cap_valid_mtu(chan, opts.imtu)) {
681 err = -EINVAL;
682 break;
683 }
684
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300685 chan->mode = opts.mode;
686 switch (chan->mode) {
Johan Hedberg38319712013-05-17 12:49:23 +0300687 case L2CAP_MODE_LE_FLOWCTL:
688 break;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200689 case L2CAP_MODE_BASIC:
Gustavo F. Padovanc1360a12011-06-10 17:02:12 -0300690 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200691 break;
692 case L2CAP_MODE_ERTM:
693 case L2CAP_MODE_STREAMING:
694 if (!disable_ertm)
695 break;
696 /* fall through */
697 default:
698 err = -EINVAL;
699 break;
700 }
701
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300702 chan->imtu = opts.imtu;
703 chan->omtu = opts.omtu;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -0300704 chan->fcs = opts.fcs;
705 chan->max_tx = opts.max_tx;
Andrei Emeltchenko6327eb92011-10-11 13:37:42 +0300706 chan->tx_win = opts.txwin_size;
Andrei Emeltchenko12d59782012-10-10 17:38:26 +0300707 chan->flush_to = opts.flush_to;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200708 break;
709
710 case L2CAP_LM:
711 if (get_user(opt, (u32 __user *) optval)) {
712 err = -EFAULT;
713 break;
714 }
715
Marcel Holtmann7d513e92014-01-15 22:37:40 -0800716 if (opt & L2CAP_LM_FIPS) {
717 err = -EINVAL;
718 break;
719 }
720
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200721 if (opt & L2CAP_LM_AUTH)
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300722 chan->sec_level = BT_SECURITY_LOW;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200723 if (opt & L2CAP_LM_ENCRYPT)
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300724 chan->sec_level = BT_SECURITY_MEDIUM;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200725 if (opt & L2CAP_LM_SECURE)
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300726 chan->sec_level = BT_SECURITY_HIGH;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200727
Andrei Emeltchenko43bd0f32011-10-11 14:04:34 +0300728 if (opt & L2CAP_LM_MASTER)
729 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
730 else
731 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
Andrei Emeltchenkoecf61bd2011-10-11 14:04:32 +0300732
733 if (opt & L2CAP_LM_RELIABLE)
734 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
735 else
736 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200737 break;
738
739 default:
740 err = -ENOPROTOOPT;
741 break;
742 }
743
744 release_sock(sk);
745 return err;
746}
747
Gustavo Padovan2d792812012-10-06 10:07:01 +0100748static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
749 char __user *optval, unsigned int optlen)
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200750{
751 struct sock *sk = sock->sk;
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300752 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200753 struct bt_security sec;
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700754 struct bt_power pwr;
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300755 struct l2cap_conn *conn;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200756 int len, err = 0;
757 u32 opt;
758
759 BT_DBG("sk %p", sk);
760
761 if (level == SOL_L2CAP)
762 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
763
764 if (level != SOL_BLUETOOTH)
765 return -ENOPROTOOPT;
766
767 lock_sock(sk);
768
769 switch (optname) {
770 case BT_SECURITY:
Gustavo F. Padovan715ec002011-05-02 17:13:55 -0300771 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
Gustavo Padovan2d792812012-10-06 10:07:01 +0100772 chan->chan_type != L2CAP_CHAN_RAW) {
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200773 err = -EINVAL;
774 break;
775 }
776
777 sec.level = BT_SECURITY_LOW;
778
779 len = min_t(unsigned int, sizeof(sec), optlen);
780 if (copy_from_user((char *) &sec, optval, len)) {
781 err = -EFAULT;
782 break;
783 }
784
785 if (sec.level < BT_SECURITY_LOW ||
Gustavo Padovan2d792812012-10-06 10:07:01 +0100786 sec.level > BT_SECURITY_HIGH) {
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200787 err = -EINVAL;
788 break;
789 }
790
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300791 chan->sec_level = sec.level;
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300792
Gustavo F. Padovan0bee1d62011-11-05 19:58:31 -0200793 if (!chan->conn)
794 break;
795
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300796 conn = chan->conn;
Gustavo F. Padovan0bee1d62011-11-05 19:58:31 -0200797
798 /*change security for LE channels */
Johan Hedberg073d1cf2013-04-29 19:35:35 +0300799 if (chan->scid == L2CAP_CID_ATT) {
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300800 if (!conn->hcon->out) {
801 err = -EINVAL;
802 break;
803 }
804
Vinicius Costa Gomescc110922012-08-23 21:32:43 -0300805 if (smp_conn_security(conn->hcon, sec.level))
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300806 break;
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300807 sk->sk_state = BT_CONFIG;
Gustavo F. Padovan3542b8542011-12-28 13:54:17 -0200808 chan->state = BT_CONFIG;
Gustavo F. Padovan0bee1d62011-11-05 19:58:31 -0200809
Gustavo Padovana7d77232012-05-13 03:20:07 -0300810 /* or for ACL link */
811 } else if ((sk->sk_state == BT_CONNECT2 &&
Gustavo Padovan2d792812012-10-06 10:07:01 +0100812 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) ||
Gustavo Padovana7d77232012-05-13 03:20:07 -0300813 sk->sk_state == BT_CONNECTED) {
814 if (!l2cap_chan_check_security(chan))
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300815 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
Gustavo Padovana7d77232012-05-13 03:20:07 -0300816 else
817 sk->sk_state_change(sk);
Gustavo F. Padovan0bee1d62011-11-05 19:58:31 -0200818 } else {
819 err = -EINVAL;
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300820 }
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200821 break;
822
823 case BT_DEFER_SETUP:
824 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
825 err = -EINVAL;
826 break;
827 }
828
829 if (get_user(opt, (u32 __user *) optval)) {
830 err = -EFAULT;
831 break;
832 }
833
Marcel Holtmannbdc25782013-10-14 02:45:34 -0700834 if (opt) {
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300835 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
Marcel Holtmannbdc25782013-10-14 02:45:34 -0700836 set_bit(FLAG_DEFER_SETUP, &chan->flags);
837 } else {
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300838 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
Marcel Holtmannbdc25782013-10-14 02:45:34 -0700839 clear_bit(FLAG_DEFER_SETUP, &chan->flags);
840 }
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200841 break;
842
843 case BT_FLUSHABLE:
844 if (get_user(opt, (u32 __user *) optval)) {
845 err = -EFAULT;
846 break;
847 }
848
849 if (opt > BT_FLUSHABLE_ON) {
850 err = -EINVAL;
851 break;
852 }
853
854 if (opt == BT_FLUSHABLE_OFF) {
Johannes Bergc1f23a22013-10-07 18:19:16 +0200855 conn = chan->conn;
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300856 /* proceed further only when we have l2cap_conn and
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200857 No Flush support in the LM */
858 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
859 err = -EINVAL;
860 break;
861 }
862 }
863
Andrei Emeltchenkod57b0e82011-10-11 14:04:31 +0300864 if (opt)
865 set_bit(FLAG_FLUSHABLE, &chan->flags);
866 else
867 clear_bit(FLAG_FLUSHABLE, &chan->flags);
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200868 break;
869
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700870 case BT_POWER:
871 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
Gustavo Padovan2d792812012-10-06 10:07:01 +0100872 chan->chan_type != L2CAP_CHAN_RAW) {
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700873 err = -EINVAL;
874 break;
875 }
876
877 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
878
879 len = min_t(unsigned int, sizeof(pwr), optlen);
880 if (copy_from_user((char *) &pwr, optval, len)) {
881 err = -EFAULT;
882 break;
883 }
Andrei Emeltchenko15770b12011-10-11 14:04:33 +0300884
885 if (pwr.force_active)
886 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
887 else
888 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700889 break;
890
Mat Martineau2ea66482011-11-02 16:18:30 -0700891 case BT_CHANNEL_POLICY:
Mat Martineau2ea66482011-11-02 16:18:30 -0700892 if (get_user(opt, (u32 __user *) optval)) {
893 err = -EFAULT;
894 break;
895 }
896
897 if (opt > BT_CHANNEL_POLICY_AMP_PREFERRED) {
898 err = -EINVAL;
899 break;
900 }
901
902 if (chan->mode != L2CAP_MODE_ERTM &&
Gustavo Padovan2d792812012-10-06 10:07:01 +0100903 chan->mode != L2CAP_MODE_STREAMING) {
Mat Martineau2ea66482011-11-02 16:18:30 -0700904 err = -EOPNOTSUPP;
905 break;
906 }
907
908 chan->chan_policy = (u8) opt;
Mat Martineau3f7a56c2012-10-23 15:24:23 -0700909
910 if (sk->sk_state == BT_CONNECTED &&
911 chan->move_role == L2CAP_MOVE_ROLE_NONE)
912 l2cap_move_start(chan);
913
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200914 break;
915
Johan Hedberg1f435422013-12-02 16:34:18 +0200916 case BT_SNDMTU:
917 if (!enable_lecoc) {
918 err = -EPROTONOSUPPORT;
919 break;
920 }
921
922 if (!bdaddr_type_is_le(chan->src_type)) {
923 err = -EINVAL;
924 break;
925 }
926
927 /* Setting is not supported as it's the remote side that
928 * decides this.
929 */
930 err = -EPERM;
931 break;
932
933 case BT_RCVMTU:
934 if (!enable_lecoc) {
935 err = -EPROTONOSUPPORT;
936 break;
937 }
938
939 if (!bdaddr_type_is_le(chan->src_type)) {
940 err = -EINVAL;
941 break;
942 }
943
944 if (sk->sk_state == BT_CONNECTED) {
945 err = -EISCONN;
946 break;
947 }
948
949 if (get_user(opt, (u32 __user *) optval)) {
950 err = -EFAULT;
951 break;
952 }
953
954 chan->imtu = opt;
955 break;
956
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200957 default:
958 err = -ENOPROTOOPT;
959 break;
960 }
961
962 release_sock(sk);
963 return err;
964}
965
Gustavo Padovan2d792812012-10-06 10:07:01 +0100966static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
967 struct msghdr *msg, size_t len)
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200968{
969 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300970 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200971 int err;
972
973 BT_DBG("sock %p, sk %p", sock, sk);
974
975 err = sock_error(sk);
976 if (err)
977 return err;
978
979 if (msg->msg_flags & MSG_OOB)
980 return -EOPNOTSUPP;
981
Mat Martineaua6a55682012-05-04 14:20:31 -0700982 if (sk->sk_state != BT_CONNECTED)
Gustavo F. Padovan9a91a042011-04-28 18:50:17 -0300983 return -ENOTCONN;
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200984
Johan Hedberge793dcf2013-09-16 13:05:19 +0300985 lock_sock(sk);
986 err = bt_sock_wait_ready(sk, msg->msg_flags);
987 release_sock(sk);
988 if (err)
989 return err;
990
Mat Martineaua6a55682012-05-04 14:20:31 -0700991 l2cap_chan_lock(chan);
Luiz Augusto von Dentz5e59b792011-11-01 10:58:57 +0200992 err = l2cap_chan_send(chan, msg, len, sk->sk_priority);
Mat Martineaua6a55682012-05-04 14:20:31 -0700993 l2cap_chan_unlock(chan);
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200994
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200995 return err;
996}
997
Gustavo Padovan2d792812012-10-06 10:07:01 +0100998static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
999 struct msghdr *msg, size_t len, int flags)
Gustavo F. Padovan68983252011-02-04 03:02:31 -02001000{
1001 struct sock *sk = sock->sk;
Mat Martineaue3281402011-07-07 09:39:02 -07001002 struct l2cap_pinfo *pi = l2cap_pi(sk);
1003 int err;
Gustavo F. Padovan68983252011-02-04 03:02:31 -02001004
1005 lock_sock(sk);
1006
Gustavo Padovanc5daa682012-05-16 12:17:10 -03001007 if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
1008 &bt_sk(sk)->flags)) {
Johan Hedberg38319712013-05-17 12:49:23 +03001009 if (bdaddr_type_is_le(pi->chan->src_type)) {
1010 sk->sk_state = BT_CONNECTED;
1011 pi->chan->state = BT_CONNECTED;
1012 __l2cap_le_connect_rsp_defer(pi->chan);
1013 } else {
1014 sk->sk_state = BT_CONFIG;
1015 pi->chan->state = BT_CONFIG;
1016 __l2cap_connect_rsp_defer(pi->chan);
1017 }
Gustavo F. Padovan8c1d7872011-04-13 20:23:55 -03001018
Johan Hedberg970871b2013-09-25 13:26:05 +03001019 err = 0;
1020 goto done;
Gustavo F. Padovan68983252011-02-04 03:02:31 -02001021 }
1022
1023 release_sock(sk);
1024
1025 if (sock->type == SOCK_STREAM)
Mat Martineaue3281402011-07-07 09:39:02 -07001026 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
1027 else
1028 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
Gustavo F. Padovan68983252011-02-04 03:02:31 -02001029
Mat Martineaue3281402011-07-07 09:39:02 -07001030 if (pi->chan->mode != L2CAP_MODE_ERTM)
1031 return err;
1032
1033 /* Attempt to put pending rx data in the socket buffer */
1034
1035 lock_sock(sk);
1036
1037 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
1038 goto done;
1039
1040 if (pi->rx_busy_skb) {
1041 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
1042 pi->rx_busy_skb = NULL;
1043 else
1044 goto done;
1045 }
1046
1047 /* Restore data flow when half of the receive buffer is
1048 * available. This avoids resending large numbers of
1049 * frames.
1050 */
1051 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
1052 l2cap_chan_busy(pi->chan, 0);
1053
1054done:
1055 release_sock(sk);
1056 return err;
Gustavo F. Padovan68983252011-02-04 03:02:31 -02001057}
1058
Gustavo F. Padovan05fc1572011-02-04 03:26:01 -02001059/* Kill socket (only if zapped and orphan)
1060 * Must be called on unlocked socket.
1061 */
Gustavo F. Padovanba3bd0e2011-05-16 18:23:24 -03001062static void l2cap_sock_kill(struct sock *sk)
Gustavo F. Padovan05fc1572011-02-04 03:26:01 -02001063{
1064 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
1065 return;
1066
Andrei Emeltchenkoe05dcc32012-02-17 11:40:56 +02001067 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
Gustavo F. Padovan05fc1572011-02-04 03:26:01 -02001068
1069 /* Kill poor orphan */
Gustavo F. Padovan6ff5abb2011-04-25 15:10:41 -03001070
Jaganath Kanakkassery4af66c62012-07-13 18:17:55 +05301071 l2cap_chan_put(l2cap_pi(sk)->chan);
Gustavo F. Padovan05fc1572011-02-04 03:26:01 -02001072 sock_set_flag(sk, SOCK_DEAD);
1073 sock_put(sk);
1074}
1075
Gustavo Padovandc253062013-10-15 19:24:49 -03001076static int __l2cap_wait_ack(struct sock *sk)
1077{
1078 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1079 DECLARE_WAITQUEUE(wait, current);
1080 int err = 0;
1081 int timeo = HZ/5;
1082
1083 add_wait_queue(sk_sleep(sk), &wait);
1084 set_current_state(TASK_INTERRUPTIBLE);
1085 while (chan->unacked_frames > 0 && chan->conn) {
1086 if (!timeo)
1087 timeo = HZ/5;
1088
1089 if (signal_pending(current)) {
1090 err = sock_intr_errno(timeo);
1091 break;
1092 }
1093
1094 release_sock(sk);
1095 timeo = schedule_timeout(timeo);
1096 lock_sock(sk);
1097 set_current_state(TASK_INTERRUPTIBLE);
1098
1099 err = sock_error(sk);
1100 if (err)
1101 break;
1102 }
1103 set_current_state(TASK_RUNNING);
1104 remove_wait_queue(sk_sleep(sk), &wait);
1105 return err;
1106}
1107
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001108static int l2cap_sock_shutdown(struct socket *sock, int how)
1109{
1110 struct sock *sk = sock->sk;
Andrei Emeltchenko7ddb6e02012-02-14 15:12:57 +02001111 struct l2cap_chan *chan;
Andrei Emeltchenko3df91ea2012-02-21 12:54:55 +02001112 struct l2cap_conn *conn;
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001113 int err = 0;
1114
1115 BT_DBG("sock %p, sk %p", sock, sk);
1116
1117 if (!sk)
1118 return 0;
1119
Andrei Emeltchenko7ddb6e02012-02-14 15:12:57 +02001120 chan = l2cap_pi(sk)->chan;
Andrei Emeltchenko3df91ea2012-02-21 12:54:55 +02001121 conn = chan->conn;
1122
1123 if (conn)
1124 mutex_lock(&conn->chan_lock);
Andrei Emeltchenko7ddb6e02012-02-14 15:12:57 +02001125
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001126 l2cap_chan_lock(chan);
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001127 lock_sock(sk);
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001128
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001129 if (!sk->sk_shutdown) {
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001130 if (chan->mode == L2CAP_MODE_ERTM)
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001131 err = __l2cap_wait_ack(sk);
1132
1133 sk->sk_shutdown = SHUTDOWN_MASK;
Andrei Emeltchenko3df91ea2012-02-21 12:54:55 +02001134
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001135 release_sock(sk);
Gustavo F. Padovan0f852722011-05-04 19:42:50 -03001136 l2cap_chan_close(chan, 0);
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001137 lock_sock(sk);
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001138
1139 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
1140 err = bt_sock_wait_state(sk, BT_CLOSED,
Gustavo Padovan2d792812012-10-06 10:07:01 +01001141 sk->sk_lingertime);
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001142 }
1143
1144 if (!err && sk->sk_err)
1145 err = -sk->sk_err;
1146
1147 release_sock(sk);
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001148 l2cap_chan_unlock(chan);
Andrei Emeltchenko3df91ea2012-02-21 12:54:55 +02001149
1150 if (conn)
1151 mutex_unlock(&conn->chan_lock);
1152
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001153 return err;
1154}
1155
Gustavo F. Padovan554f05b2011-02-04 02:36:42 -02001156static int l2cap_sock_release(struct socket *sock)
1157{
1158 struct sock *sk = sock->sk;
1159 int err;
1160
1161 BT_DBG("sock %p, sk %p", sock, sk);
1162
1163 if (!sk)
1164 return 0;
1165
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001166 bt_sock_unlink(&l2cap_sk_list, sk);
1167
Gustavo F. Padovan554f05b2011-02-04 02:36:42 -02001168 err = l2cap_sock_shutdown(sock, 2);
1169
1170 sock_orphan(sk);
1171 l2cap_sock_kill(sk);
1172 return err;
1173}
1174
Andrei Emeltchenkoc0df7f62012-05-27 22:27:52 -03001175static void l2cap_sock_cleanup_listen(struct sock *parent)
1176{
1177 struct sock *sk;
1178
1179 BT_DBG("parent %p", parent);
1180
1181 /* Close not yet accepted channels */
1182 while ((sk = bt_accept_dequeue(parent, NULL))) {
1183 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1184
1185 l2cap_chan_lock(chan);
1186 __clear_chan_timer(chan);
1187 l2cap_chan_close(chan, ECONNRESET);
1188 l2cap_chan_unlock(chan);
1189
1190 l2cap_sock_kill(sk);
1191 }
1192}
1193
Gustavo Padovan80b98022012-05-27 22:27:51 -03001194static struct l2cap_chan *l2cap_sock_new_connection_cb(struct l2cap_chan *chan)
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001195{
Gustavo Padovan80b98022012-05-27 22:27:51 -03001196 struct sock *sk, *parent = chan->data;
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001197
Gustavo Padovan8ffb9292013-10-21 14:21:41 -02001198 lock_sock(parent);
1199
Gustavo Padovan53826692012-05-27 22:27:55 -03001200 /* Check for backlog size */
1201 if (sk_acceptq_is_full(parent)) {
1202 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1203 return NULL;
1204 }
1205
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001206 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
Gustavo Padovan2d792812012-10-06 10:07:01 +01001207 GFP_ATOMIC);
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001208 if (!sk)
1209 return NULL;
1210
Octavian Purdilad22015a2012-01-22 00:28:34 +02001211 bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
1212
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001213 l2cap_sock_init(sk, parent);
1214
Gustavo Padovan644912e2012-10-12 19:35:23 +08001215 bt_accept_enqueue(parent, sk);
1216
Gustavo Padovan8ffb9292013-10-21 14:21:41 -02001217 release_sock(parent);
1218
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001219 return l2cap_pi(sk)->chan;
1220}
1221
Gustavo Padovan80b98022012-05-27 22:27:51 -03001222static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
Gustavo F. Padovan23070492011-05-16 17:57:22 -03001223{
Gustavo Padovan80b98022012-05-27 22:27:51 -03001224 struct sock *sk = chan->data;
Marcel Holtmann84b34d92013-10-13 11:36:07 -07001225 int err;
Gustavo F. Padovan23070492011-05-16 17:57:22 -03001226
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001227 lock_sock(sk);
1228
Marcel Holtmann84b34d92013-10-13 11:36:07 -07001229 if (l2cap_pi(sk)->rx_busy_skb) {
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001230 err = -ENOMEM;
1231 goto done;
1232 }
Mat Martineaue3281402011-07-07 09:39:02 -07001233
1234 err = sock_queue_rcv_skb(sk, skb);
1235
1236 /* For ERTM, handle one skb that doesn't fit into the recv
1237 * buffer. This is important to do because the data frames
1238 * have already been acked, so the skb cannot be discarded.
1239 *
1240 * Notify the l2cap core that the buffer is full, so the
1241 * LOCAL_BUSY state is entered and no more frames are
1242 * acked and reassembled until there is buffer space
1243 * available.
1244 */
Marcel Holtmann84b34d92013-10-13 11:36:07 -07001245 if (err < 0 && chan->mode == L2CAP_MODE_ERTM) {
1246 l2cap_pi(sk)->rx_busy_skb = skb;
1247 l2cap_chan_busy(chan, 1);
Mat Martineaue3281402011-07-07 09:39:02 -07001248 err = 0;
1249 }
1250
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001251done:
1252 release_sock(sk);
1253
Mat Martineaue3281402011-07-07 09:39:02 -07001254 return err;
Gustavo F. Padovan23070492011-05-16 17:57:22 -03001255}
1256
Gustavo Padovan80b98022012-05-27 22:27:51 -03001257static void l2cap_sock_close_cb(struct l2cap_chan *chan)
Gustavo F. Padovanba3bd0e2011-05-16 18:23:24 -03001258{
Gustavo Padovan80b98022012-05-27 22:27:51 -03001259 struct sock *sk = chan->data;
Gustavo F. Padovanba3bd0e2011-05-16 18:23:24 -03001260
1261 l2cap_sock_kill(sk);
1262}
1263
Andrei Emeltchenkoc0df7f62012-05-27 22:27:52 -03001264static void l2cap_sock_teardown_cb(struct l2cap_chan *chan, int err)
1265{
1266 struct sock *sk = chan->data;
1267 struct sock *parent;
1268
1269 lock_sock(sk);
1270
1271 parent = bt_sk(sk)->parent;
1272
1273 sock_set_flag(sk, SOCK_ZAPPED);
1274
1275 switch (chan->state) {
1276 case BT_OPEN:
1277 case BT_BOUND:
1278 case BT_CLOSED:
1279 break;
1280 case BT_LISTEN:
1281 l2cap_sock_cleanup_listen(sk);
1282 sk->sk_state = BT_CLOSED;
1283 chan->state = BT_CLOSED;
1284
1285 break;
1286 default:
1287 sk->sk_state = BT_CLOSED;
1288 chan->state = BT_CLOSED;
1289
1290 sk->sk_err = err;
1291
1292 if (parent) {
1293 bt_accept_unlink(sk);
1294 parent->sk_data_ready(parent, 0);
1295 } else {
1296 sk->sk_state_change(sk);
1297 }
1298
1299 break;
1300 }
1301
1302 release_sock(sk);
1303}
1304
Gustavo Padovan53f52122013-10-15 19:24:45 -03001305static void l2cap_sock_state_change_cb(struct l2cap_chan *chan, int state,
1306 int err)
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -03001307{
Gustavo Padovan80b98022012-05-27 22:27:51 -03001308 struct sock *sk = chan->data;
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -03001309
1310 sk->sk_state = state;
Gustavo Padovan53f52122013-10-15 19:24:45 -03001311
1312 if (err)
1313 sk->sk_err = err;
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -03001314}
1315
Andrei Emeltchenko2f7719c2012-01-20 14:08:03 +02001316static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
Gustavo Padovan90338942012-04-06 20:15:47 -03001317 unsigned long len, int nb)
Andrei Emeltchenko2f7719c2012-01-20 14:08:03 +02001318{
Gustavo Padovan0f2c6152013-10-21 14:21:38 -02001319 struct sock *sk = chan->data;
Gustavo Padovan90338942012-04-06 20:15:47 -03001320 struct sk_buff *skb;
1321 int err;
Andrei Emeltchenko2f7719c2012-01-20 14:08:03 +02001322
Mat Martineaua6a55682012-05-04 14:20:31 -07001323 l2cap_chan_unlock(chan);
Gustavo Padovan0f2c6152013-10-21 14:21:38 -02001324 skb = bt_skb_send_alloc(sk, len, nb, &err);
Mat Martineaua6a55682012-05-04 14:20:31 -07001325 l2cap_chan_lock(chan);
1326
Gustavo Padovan90338942012-04-06 20:15:47 -03001327 if (!skb)
1328 return ERR_PTR(err);
1329
Gustavo Padovan0e790c62013-10-21 18:22:24 -02001330 bt_cb(skb)->chan = chan;
1331
Gustavo Padovan90338942012-04-06 20:15:47 -03001332 return skb;
Andrei Emeltchenko2f7719c2012-01-20 14:08:03 +02001333}
1334
Andrei Emeltchenko54a59aa2012-05-27 22:27:53 -03001335static void l2cap_sock_ready_cb(struct l2cap_chan *chan)
1336{
1337 struct sock *sk = chan->data;
1338 struct sock *parent;
1339
1340 lock_sock(sk);
1341
1342 parent = bt_sk(sk)->parent;
1343
1344 BT_DBG("sk %p, parent %p", sk, parent);
1345
1346 sk->sk_state = BT_CONNECTED;
1347 sk->sk_state_change(sk);
1348
1349 if (parent)
1350 parent->sk_data_ready(parent, 0);
1351
1352 release_sock(sk);
1353}
1354
Gustavo Padovan2dc4e512012-10-12 19:35:24 +08001355static void l2cap_sock_defer_cb(struct l2cap_chan *chan)
1356{
Gustavo Padovanacdcabf2013-10-21 14:21:39 -02001357 struct sock *parent, *sk = chan->data;
Gustavo Padovan2dc4e512012-10-12 19:35:24 +08001358
Gustavo Padovanacdcabf2013-10-21 14:21:39 -02001359 lock_sock(sk);
1360
1361 parent = bt_sk(sk)->parent;
Gustavo Padovan2dc4e512012-10-12 19:35:24 +08001362 if (parent)
1363 parent->sk_data_ready(parent, 0);
Gustavo Padovanacdcabf2013-10-21 14:21:39 -02001364
1365 release_sock(sk);
Gustavo Padovan2dc4e512012-10-12 19:35:24 +08001366}
1367
Marcel Holtmannd97c8992013-10-14 02:53:54 -07001368static void l2cap_sock_resume_cb(struct l2cap_chan *chan)
1369{
1370 struct sock *sk = chan->data;
1371
1372 clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1373 sk->sk_state_change(sk);
1374}
1375
Gustavo Padovan5ec1bbe2013-10-15 19:24:48 -03001376static void l2cap_sock_set_shutdown_cb(struct l2cap_chan *chan)
1377{
1378 struct sock *sk = chan->data;
1379
1380 lock_sock(sk);
1381 sk->sk_shutdown = SHUTDOWN_MASK;
1382 release_sock(sk);
1383}
1384
Gustavo Padovan8d836d72013-10-15 19:24:47 -03001385static long l2cap_sock_get_sndtimeo_cb(struct l2cap_chan *chan)
1386{
1387 struct sock *sk = chan->data;
1388
1389 return sk->sk_sndtimeo;
1390}
1391
Johan Hedberg837776f2013-10-15 11:03:18 +03001392static void l2cap_sock_suspend_cb(struct l2cap_chan *chan)
1393{
1394 struct sock *sk = chan->data;
1395
1396 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1397 sk->sk_state_change(sk);
1398}
1399
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001400static struct l2cap_ops l2cap_chan_ops = {
1401 .name = "L2CAP Socket Interface",
1402 .new_connection = l2cap_sock_new_connection_cb,
Gustavo F. Padovan23070492011-05-16 17:57:22 -03001403 .recv = l2cap_sock_recv_cb,
Gustavo F. Padovanba3bd0e2011-05-16 18:23:24 -03001404 .close = l2cap_sock_close_cb,
Andrei Emeltchenkoc0df7f62012-05-27 22:27:52 -03001405 .teardown = l2cap_sock_teardown_cb,
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -03001406 .state_change = l2cap_sock_state_change_cb,
Andrei Emeltchenko54a59aa2012-05-27 22:27:53 -03001407 .ready = l2cap_sock_ready_cb,
Gustavo Padovan2dc4e512012-10-12 19:35:24 +08001408 .defer = l2cap_sock_defer_cb,
Marcel Holtmannd97c8992013-10-14 02:53:54 -07001409 .resume = l2cap_sock_resume_cb,
Johan Hedberg837776f2013-10-15 11:03:18 +03001410 .suspend = l2cap_sock_suspend_cb,
Gustavo Padovan5ec1bbe2013-10-15 19:24:48 -03001411 .set_shutdown = l2cap_sock_set_shutdown_cb,
Gustavo Padovan8d836d72013-10-15 19:24:47 -03001412 .get_sndtimeo = l2cap_sock_get_sndtimeo_cb,
Andrei Emeltchenko2f7719c2012-01-20 14:08:03 +02001413 .alloc_skb = l2cap_sock_alloc_skb_cb,
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001414};
1415
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001416static void l2cap_sock_destruct(struct sock *sk)
1417{
1418 BT_DBG("sk %p", sk);
1419
Sasha Levin23d3a862012-10-08 16:48:32 -04001420 if (l2cap_pi(sk)->chan)
1421 l2cap_chan_put(l2cap_pi(sk)->chan);
Marcel Holtmann84b34d92013-10-13 11:36:07 -07001422
Mat Martineaue3281402011-07-07 09:39:02 -07001423 if (l2cap_pi(sk)->rx_busy_skb) {
1424 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
1425 l2cap_pi(sk)->rx_busy_skb = NULL;
1426 }
1427
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001428 skb_queue_purge(&sk->sk_receive_queue);
1429 skb_queue_purge(&sk->sk_write_queue);
1430}
1431
Marcel Holtmann2edf8702013-10-13 12:55:29 -07001432static void l2cap_skb_msg_name(struct sk_buff *skb, void *msg_name,
1433 int *msg_namelen)
1434{
Steffen Hurrle342dfc32014-01-17 22:53:15 +01001435 DECLARE_SOCKADDR(struct sockaddr_l2 *, la, msg_name);
Marcel Holtmann2edf8702013-10-13 12:55:29 -07001436
1437 memset(la, 0, sizeof(struct sockaddr_l2));
1438 la->l2_family = AF_BLUETOOTH;
1439 la->l2_psm = bt_cb(skb)->psm;
1440 bacpy(&la->l2_bdaddr, &bt_cb(skb)->bdaddr);
1441
1442 *msg_namelen = sizeof(struct sockaddr_l2);
1443}
1444
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001445static void l2cap_sock_init(struct sock *sk, struct sock *parent)
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001446{
Marcel Holtmann84b34d92013-10-13 11:36:07 -07001447 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001448
1449 BT_DBG("sk %p", sk);
1450
1451 if (parent) {
Gustavo F. Padovanb4450032011-04-12 18:15:09 -03001452 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1453
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001454 sk->sk_type = parent->sk_type;
Gustavo Padovanc5daa682012-05-16 12:17:10 -03001455 bt_sk(sk)->flags = bt_sk(parent)->flags;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001456
Gustavo F. Padovan715ec002011-05-02 17:13:55 -03001457 chan->chan_type = pchan->chan_type;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001458 chan->imtu = pchan->imtu;
1459 chan->omtu = pchan->omtu;
Gustavo F. Padovanb4450032011-04-12 18:15:09 -03001460 chan->conf_state = pchan->conf_state;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001461 chan->mode = pchan->mode;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -03001462 chan->fcs = pchan->fcs;
1463 chan->max_tx = pchan->max_tx;
1464 chan->tx_win = pchan->tx_win;
Andrei Emeltchenko6b3c7102011-11-02 09:57:10 +02001465 chan->tx_win_max = pchan->tx_win_max;
Gustavo F. Padovan43434782011-04-12 18:31:57 -03001466 chan->sec_level = pchan->sec_level;
Andrei Emeltchenkod57b0e82011-10-11 14:04:31 +03001467 chan->flags = pchan->flags;
Johan Hedberg0cd75f72013-05-17 13:09:05 +03001468 chan->tx_credits = pchan->tx_credits;
1469 chan->rx_credits = pchan->rx_credits;
Paul Moore6230c9b2011-10-07 09:40:59 +00001470
1471 security_sk_clone(parent, sk);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001472 } else {
Gustavo F. Padovan715ec002011-05-02 17:13:55 -03001473 switch (sk->sk_type) {
1474 case SOCK_RAW:
1475 chan->chan_type = L2CAP_CHAN_RAW;
1476 break;
1477 case SOCK_DGRAM:
1478 chan->chan_type = L2CAP_CHAN_CONN_LESS;
Marcel Holtmann2edf8702013-10-13 12:55:29 -07001479 bt_sk(sk)->skb_msg_name = l2cap_skb_msg_name;
Gustavo F. Padovan715ec002011-05-02 17:13:55 -03001480 break;
1481 case SOCK_SEQPACKET:
1482 case SOCK_STREAM:
1483 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1484 break;
1485 }
1486
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001487 chan->imtu = L2CAP_DEFAULT_MTU;
1488 chan->omtu = 0;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001489 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001490 chan->mode = L2CAP_MODE_ERTM;
Gustavo F. Padovanc1360a12011-06-10 17:02:12 -03001491 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001492 } else {
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001493 chan->mode = L2CAP_MODE_BASIC;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001494 }
Andrei Emeltchenkobd4b1652012-03-28 16:31:25 +03001495
1496 l2cap_chan_set_defaults(chan);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001497 }
1498
1499 /* Default config options */
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001500 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001501
1502 chan->data = sk;
1503 chan->ops = &l2cap_chan_ops;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001504}
1505
1506static struct proto l2cap_proto = {
1507 .name = "L2CAP",
1508 .owner = THIS_MODULE,
1509 .obj_size = sizeof(struct l2cap_pinfo)
1510};
1511
Gustavo Padovan2d792812012-10-06 10:07:01 +01001512static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
1513 int proto, gfp_t prio)
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001514{
1515 struct sock *sk;
Gustavo F. Padovandc50a062011-05-16 16:42:01 -03001516 struct l2cap_chan *chan;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001517
1518 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1519 if (!sk)
1520 return NULL;
1521
1522 sock_init_data(sock, sk);
1523 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1524
1525 sk->sk_destruct = l2cap_sock_destruct;
Marcel Holtmannba13ccd2012-03-01 14:25:33 -08001526 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001527
1528 sock_reset_flag(sk, SOCK_ZAPPED);
1529
1530 sk->sk_protocol = proto;
1531 sk->sk_state = BT_OPEN;
1532
Gustavo Padovaneef1d9b2012-03-25 13:59:16 -03001533 chan = l2cap_chan_create();
Gustavo F. Padovandc50a062011-05-16 16:42:01 -03001534 if (!chan) {
Jaganath Kanakkassery49dfbb92012-07-19 12:54:04 +05301535 sk_free(sk);
Gustavo F. Padovandc50a062011-05-16 16:42:01 -03001536 return NULL;
1537 }
1538
Mat Martineau61d6ef32012-04-27 16:50:50 -07001539 l2cap_chan_hold(chan);
1540
Gustavo F. Padovandc50a062011-05-16 16:42:01 -03001541 l2cap_pi(sk)->chan = chan;
1542
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001543 return sk;
1544}
1545
1546static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1547 int kern)
1548{
1549 struct sock *sk;
1550
1551 BT_DBG("sock %p", sock);
1552
1553 sock->state = SS_UNCONNECTED;
1554
1555 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
Gustavo Padovan2d792812012-10-06 10:07:01 +01001556 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001557 return -ESOCKTNOSUPPORT;
1558
1559 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1560 return -EPERM;
1561
1562 sock->ops = &l2cap_sock_ops;
1563
1564 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1565 if (!sk)
1566 return -ENOMEM;
1567
1568 l2cap_sock_init(sk, NULL);
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001569 bt_sock_link(&l2cap_sk_list, sk);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001570 return 0;
1571}
1572
Gustavo F. Padovancf2f90f2011-04-27 18:40:39 -03001573static const struct proto_ops l2cap_sock_ops = {
Gustavo F. Padovan65390582011-02-04 02:33:56 -02001574 .family = PF_BLUETOOTH,
1575 .owner = THIS_MODULE,
1576 .release = l2cap_sock_release,
1577 .bind = l2cap_sock_bind,
1578 .connect = l2cap_sock_connect,
1579 .listen = l2cap_sock_listen,
1580 .accept = l2cap_sock_accept,
1581 .getname = l2cap_sock_getname,
1582 .sendmsg = l2cap_sock_sendmsg,
1583 .recvmsg = l2cap_sock_recvmsg,
1584 .poll = bt_sock_poll,
1585 .ioctl = bt_sock_ioctl,
1586 .mmap = sock_no_mmap,
1587 .socketpair = sock_no_socketpair,
1588 .shutdown = l2cap_sock_shutdown,
1589 .setsockopt = l2cap_sock_setsockopt,
1590 .getsockopt = l2cap_sock_getsockopt
1591};
1592
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001593static const struct net_proto_family l2cap_sock_family_ops = {
1594 .family = PF_BLUETOOTH,
1595 .owner = THIS_MODULE,
1596 .create = l2cap_sock_create,
1597};
1598
1599int __init l2cap_init_sockets(void)
1600{
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001601 int err;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001602
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001603 err = proto_register(&l2cap_proto, 0);
1604 if (err < 0)
1605 return err;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001606
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001607 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001608 if (err < 0) {
1609 BT_ERR("L2CAP socket registration failed");
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001610 goto error;
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001611 }
1612
Al Virob0316612013-04-04 19:14:33 -04001613 err = bt_procfs_init(&init_net, "l2cap", &l2cap_sk_list,
Gustavo Padovan2d792812012-10-06 10:07:01 +01001614 NULL);
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001615 if (err < 0) {
1616 BT_ERR("Failed to create L2CAP proc file");
1617 bt_sock_unregister(BTPROTO_L2CAP);
1618 goto error;
1619 }
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001620
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001621 BT_INFO("L2CAP socket layer initialized");
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001622
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001623 return 0;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001624
1625error:
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001626 proto_unregister(&l2cap_proto);
1627 return err;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001628}
1629
1630void l2cap_cleanup_sockets(void)
1631{
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001632 bt_procfs_cleanup(&init_net, "l2cap");
David Herrmann5e9d7f82013-02-24 19:36:51 +01001633 bt_sock_unregister(BTPROTO_L2CAP);
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001634 proto_unregister(&l2cap_proto);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001635}
Johan Hedberg91497612013-12-02 11:20:20 +02001636
1637module_param(enable_lecoc, bool, 0644);
1638MODULE_PARM_DESC(enable_lecoc, "Enable support for LE CoC");