blob: ef5e5b04f34fbd3c130c74dc2a41ffe775870b3b [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
Masatake YAMATO5b28d952012-07-26 01:29:25 +090039static struct bt_sock_list l2cap_sk_list = {
40 .lock = __RW_LOCK_UNLOCKED(l2cap_sk_list.lock)
41};
42
Gustavo F. Padovancf2f90f2011-04-27 18:40:39 -030043static const struct proto_ops l2cap_sock_ops;
Gustavo F. Padovan80808e42011-05-16 17:24:37 -030044static void l2cap_sock_init(struct sock *sk, struct sock *parent);
Gustavo Padovan2d792812012-10-06 10:07:01 +010045static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
46 int proto, gfp_t prio);
Gustavo F. Padovancf2f90f2011-04-27 18:40:39 -030047
David Herrmannb3916db2013-04-05 14:57:34 +020048bool l2cap_is_socket(struct socket *sock)
49{
50 return sock && sock->ops == &l2cap_sock_ops;
51}
52EXPORT_SYMBOL(l2cap_is_socket);
53
Johan Hedberg49460962013-10-08 13:55:46 +020054static int l2cap_validate_bredr_psm(u16 psm)
55{
56 /* PSM must be odd and lsb of upper byte must be 0 */
57 if ((psm & 0x0101) != 0x0001)
58 return -EINVAL;
59
60 /* Restrict usage of well-known PSMs */
61 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE))
62 return -EACCES;
63
64 return 0;
65}
66
67static int l2cap_validate_le_psm(u16 psm)
68{
69 /* Valid LE_PSM ranges are defined only until 0x00ff */
70 if (psm > 0x00ff)
71 return -EINVAL;
72
73 /* Restrict fixed, SIG assigned PSM values to CAP_NET_BIND_SERVICE */
74 if (psm <= 0x007f && !capable(CAP_NET_BIND_SERVICE))
75 return -EACCES;
76
77 return 0;
78}
79
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -020080static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
81{
82 struct sock *sk = sock->sk;
Gustavo F. Padovan43434782011-04-12 18:31:57 -030083 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -020084 struct sockaddr_l2 la;
85 int len, err = 0;
86
87 BT_DBG("sk %p", sk);
88
89 if (!addr || addr->sa_family != AF_BLUETOOTH)
90 return -EINVAL;
91
92 memset(&la, 0, sizeof(la));
93 len = min_t(unsigned int, sizeof(la), alen);
94 memcpy(&la, addr, len);
95
Ville Tervob62f3282011-02-10 22:38:50 -030096 if (la.l2_cid && la.l2_psm)
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -020097 return -EINVAL;
98
Johan Hedberg80c1a2e2013-10-14 21:17:52 +030099 if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
100 return -EINVAL;
101
Johan Hedberg21626e62014-01-24 10:35:41 +0200102 if (la.l2_cid) {
103 /* When the socket gets created it defaults to
104 * CHAN_CONN_ORIENTED, so we need to overwrite the
105 * default here.
106 */
107 chan->chan_type = L2CAP_CHAN_FIXED;
108 chan->omtu = L2CAP_DEFAULT_MTU;
109 }
110
Johan Hedbergbfe46552013-10-16 17:13:26 +0300111 if (bdaddr_type_is_le(la.l2_bdaddr_type)) {
Johan Hedbergbfe46552013-10-16 17:13:26 +0300112 /* We only allow ATT user space socket */
Johan Hedberg91497612013-12-02 11:20:20 +0200113 if (la.l2_cid &&
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700114 la.l2_cid != cpu_to_le16(L2CAP_CID_ATT))
Johan Hedbergbfe46552013-10-16 17:13:26 +0300115 return -EINVAL;
116 }
117
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200118 lock_sock(sk);
119
120 if (sk->sk_state != BT_OPEN) {
121 err = -EBADFD;
122 goto done;
123 }
124
125 if (la.l2_psm) {
126 __u16 psm = __le16_to_cpu(la.l2_psm);
127
Johan Hedberg49460962013-10-08 13:55:46 +0200128 if (la.l2_bdaddr_type == BDADDR_BREDR)
129 err = l2cap_validate_bredr_psm(psm);
130 else
131 err = l2cap_validate_le_psm(psm);
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200132
Johan Hedberg49460962013-10-08 13:55:46 +0200133 if (err)
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200134 goto done;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200135 }
136
Ville Tervob62f3282011-02-10 22:38:50 -0300137 if (la.l2_cid)
Santosh Nayak6e4aff12012-03-01 22:46:36 +0530138 err = l2cap_add_scid(chan, __le16_to_cpu(la.l2_cid));
Gustavo F. Padovan9e4425f2011-04-18 18:38:43 -0300139 else
140 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
Ville Tervob62f3282011-02-10 22:38:50 -0300141
Gustavo F. Padovan9e4425f2011-04-18 18:38:43 -0300142 if (err < 0)
143 goto done;
144
Marcel Holtmann6a974b52013-10-12 07:19:31 -0700145 switch (chan->chan_type) {
Marcel Holtmann3124b842013-10-12 07:19:32 -0700146 case L2CAP_CHAN_CONN_LESS:
147 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_3DSP)
148 chan->sec_level = BT_SECURITY_SDP;
149 break;
Marcel Holtmann6a974b52013-10-12 07:19:31 -0700150 case L2CAP_CHAN_CONN_ORIENTED:
151 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_SDP ||
152 __le16_to_cpu(la.l2_psm) == L2CAP_PSM_RFCOMM)
153 chan->sec_level = BT_SECURITY_SDP;
154 break;
Johan Hedbergcb6ca8e2014-01-06 18:27:02 +0200155 case L2CAP_CHAN_RAW:
156 chan->sec_level = BT_SECURITY_SDP;
157 break;
Marcel Holtmann6a974b52013-10-12 07:19:31 -0700158 }
Gustavo F. Padovan9e4425f2011-04-18 18:38:43 -0300159
Marcel Holtmann7eafc592013-10-13 08:12:47 -0700160 bacpy(&chan->src, &la.l2_bdaddr);
Marcel Holtmann4f1654e2013-10-13 08:50:41 -0700161 chan->src_type = la.l2_bdaddr_type;
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -0300162
Johan Hedberg38319712013-05-17 12:49:23 +0300163 if (chan->psm && bdaddr_type_is_le(chan->src_type))
Johan Hedberg0ce43ce2013-12-05 14:55:33 +0200164 chan->mode = L2CAP_MODE_LE_FLOWCTL;
Johan Hedberg38319712013-05-17 12:49:23 +0300165
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -0300166 chan->state = BT_BOUND;
Gustavo F. Padovan9e4425f2011-04-18 18:38:43 -0300167 sk->sk_state = BT_BOUND;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200168
169done:
170 release_sock(sk);
171 return err;
172}
173
Gustavo Padovan2d792812012-10-06 10:07:01 +0100174static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr,
175 int alen, int flags)
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200176{
177 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300178 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200179 struct sockaddr_l2 la;
180 int len, err = 0;
181
182 BT_DBG("sk %p", sk);
183
184 if (!addr || alen < sizeof(addr->sa_family) ||
185 addr->sa_family != AF_BLUETOOTH)
186 return -EINVAL;
187
188 memset(&la, 0, sizeof(la));
189 len = min_t(unsigned int, sizeof(la), alen);
190 memcpy(&la, addr, len);
191
Ville Tervoacd7d372011-02-10 22:38:49 -0300192 if (la.l2_cid && la.l2_psm)
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200193 return -EINVAL;
194
Johan Hedberg80c1a2e2013-10-14 21:17:52 +0300195 if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
196 return -EINVAL;
197
Johan Hedbergeb622492013-10-18 11:49:25 +0300198 /* Check that the socket wasn't bound to something that
199 * conflicts with the address given to connect(). If chan->src
200 * is BDADDR_ANY it means bind() was never used, in which case
201 * chan->src_type and la.l2_bdaddr_type do not need to match.
202 */
203 if (chan->src_type == BDADDR_BREDR && bacmp(&chan->src, BDADDR_ANY) &&
204 bdaddr_type_is_le(la.l2_bdaddr_type)) {
205 /* Old user space versions will try to incorrectly bind
206 * the ATT socket using BDADDR_BREDR. We need to accept
207 * this and fix up the source address type only when
208 * both the source CID and destination CID indicate
209 * ATT. Anything else is an invalid combination.
210 */
211 if (chan->scid != L2CAP_CID_ATT ||
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700212 la.l2_cid != cpu_to_le16(L2CAP_CID_ATT))
Johan Hedbergeb622492013-10-18 11:49:25 +0300213 return -EINVAL;
214
215 /* We don't have the hdev available here to make a
216 * better decision on random vs public, but since all
217 * user space versions that exhibit this issue anyway do
218 * not support random local addresses assuming public
219 * here is good enough.
220 */
221 chan->src_type = BDADDR_LE_PUBLIC;
222 }
Johan Hedberg1f209382013-10-14 21:17:53 +0300223
224 if (chan->src_type != BDADDR_BREDR && la.l2_bdaddr_type == BDADDR_BREDR)
225 return -EINVAL;
226
Johan Hedbergbfe46552013-10-16 17:13:26 +0300227 if (bdaddr_type_is_le(la.l2_bdaddr_type)) {
Johan Hedbergbfe46552013-10-16 17:13:26 +0300228 /* We only allow ATT user space socket */
Johan Hedberg91497612013-12-02 11:20:20 +0200229 if (la.l2_cid &&
Joe Perchesdcf4adb2014-03-12 10:52:35 -0700230 la.l2_cid != cpu_to_le16(L2CAP_CID_ATT))
Johan Hedbergbfe46552013-10-16 17:13:26 +0300231 return -EINVAL;
232 }
233
Johan Hedberg38319712013-05-17 12:49:23 +0300234 if (chan->psm && bdaddr_type_is_le(chan->src_type))
Johan Hedberg0ce43ce2013-12-05 14:55:33 +0200235 chan->mode = L2CAP_MODE_LE_FLOWCTL;
Johan Hedberg38319712013-05-17 12:49:23 +0300236
Santosh Nayak6e4aff12012-03-01 22:46:36 +0530237 err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),
Andre Guedes8e9f9892012-04-24 21:02:55 -0300238 &la.l2_bdaddr, la.l2_bdaddr_type);
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200239 if (err)
Andrei Emeltchenkob3fb6112012-02-22 17:11:57 +0200240 return err;
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200241
Andrei Emeltchenko6be36552012-02-22 17:11:56 +0200242 lock_sock(sk);
243
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200244 err = bt_sock_wait_state(sk, BT_CONNECTED,
Gustavo Padovan2d792812012-10-06 10:07:01 +0100245 sock_sndtimeo(sk, flags & O_NONBLOCK));
Andrei Emeltchenkob3fb6112012-02-22 17:11:57 +0200246
247 release_sock(sk);
248
Gustavo F. Padovan4e34c502011-02-04 02:56:13 -0200249 return err;
250}
251
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200252static int l2cap_sock_listen(struct socket *sock, int backlog)
253{
254 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300255 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200256 int err = 0;
257
258 BT_DBG("sk %p backlog %d", sk, backlog);
259
260 lock_sock(sk);
261
Marcel Holtmann6b3af732012-04-19 13:43:51 +0200262 if (sk->sk_state != BT_BOUND) {
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200263 err = -EBADFD;
264 goto done;
265 }
266
Marcel Holtmann6b3af732012-04-19 13:43:51 +0200267 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM) {
268 err = -EINVAL;
269 goto done;
270 }
271
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300272 switch (chan->mode) {
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200273 case L2CAP_MODE_BASIC:
Johan Hedberg38319712013-05-17 12:49:23 +0300274 case L2CAP_MODE_LE_FLOWCTL:
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200275 break;
276 case L2CAP_MODE_ERTM:
277 case L2CAP_MODE_STREAMING:
278 if (!disable_ertm)
279 break;
280 /* fall through */
281 default:
282 err = -ENOTSUPP;
283 goto done;
284 }
285
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200286 sk->sk_max_ack_backlog = backlog;
287 sk->sk_ack_backlog = 0;
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -0300288
289 chan->state = BT_LISTEN;
Gustavo F. Padovanaf6bcd82011-02-04 02:40:28 -0200290 sk->sk_state = BT_LISTEN;
291
292done:
293 release_sock(sk);
294 return err;
295}
296
Gustavo Padovan2d792812012-10-06 10:07:01 +0100297static int l2cap_sock_accept(struct socket *sock, struct socket *newsock,
298 int flags)
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200299{
300 DECLARE_WAITQUEUE(wait, current);
301 struct sock *sk = sock->sk, *nsk;
302 long timeo;
303 int err = 0;
304
305 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
306
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200307 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
308
309 BT_DBG("sk %p timeo %ld", sk, timeo);
310
311 /* Wait for an incoming connection. (wake-one). */
312 add_wait_queue_exclusive(sk_sleep(sk), &wait);
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400313 while (1) {
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200314 set_current_state(TASK_INTERRUPTIBLE);
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200315
316 if (sk->sk_state != BT_LISTEN) {
317 err = -EBADFD;
318 break;
319 }
320
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400321 nsk = bt_accept_dequeue(sk, newsock);
322 if (nsk)
323 break;
324
325 if (!timeo) {
326 err = -EAGAIN;
327 break;
328 }
329
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200330 if (signal_pending(current)) {
331 err = sock_intr_errno(timeo);
332 break;
333 }
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400334
335 release_sock(sk);
336 timeo = schedule_timeout(timeo);
337 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200338 }
Peter Hurleyf9a3c202011-07-24 00:10:52 -0400339 __set_current_state(TASK_RUNNING);
Gustavo F. Padovanc47b7c72011-02-04 02:42:23 -0200340 remove_wait_queue(sk_sleep(sk), &wait);
341
342 if (err)
343 goto done;
344
345 newsock->state = SS_CONNECTED;
346
347 BT_DBG("new socket %p", nsk);
348
349done:
350 release_sock(sk);
351 return err;
352}
353
Gustavo Padovan2d792812012-10-06 10:07:01 +0100354static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr,
355 int *len, int peer)
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200356{
357 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
358 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300359 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200360
361 BT_DBG("sock %p, sk %p", sock, sk);
362
Johan Hedberge8b1ab92014-03-26 15:49:18 +0200363 if (peer && sk->sk_state != BT_CONNECTED &&
364 sk->sk_state != BT_CONNECT && sk->sk_state != BT_CONNECT2)
Johan Hedbergb783fbc2014-01-28 15:16:49 -0800365 return -ENOTCONN;
366
Mathias Krause792039c2012-08-15 11:31:51 +0000367 memset(la, 0, sizeof(struct sockaddr_l2));
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200368 addr->sa_family = AF_BLUETOOTH;
369 *len = sizeof(struct sockaddr_l2);
370
Johan Hedbergd7e5e762014-01-28 15:16:51 -0800371 la->l2_psm = chan->psm;
372
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200373 if (peer) {
Marcel Holtmann7eafc592013-10-13 08:12:47 -0700374 bacpy(&la->l2_bdaddr, &chan->dst);
Gustavo F. Padovanfe4128e2011-04-13 19:50:45 -0300375 la->l2_cid = cpu_to_le16(chan->dcid);
Marcel Holtmann4f1654e2013-10-13 08:50:41 -0700376 la->l2_bdaddr_type = chan->dst_type;
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200377 } else {
Marcel Holtmann7eafc592013-10-13 08:12:47 -0700378 bacpy(&la->l2_bdaddr, &chan->src);
Gustavo F. Padovanfe4128e2011-04-13 19:50:45 -0300379 la->l2_cid = cpu_to_le16(chan->scid);
Marcel Holtmann4f1654e2013-10-13 08:50:41 -0700380 la->l2_bdaddr_type = chan->src_type;
Gustavo F. Padovand7175d52011-02-04 02:43:46 -0200381 }
382
383 return 0;
384}
385
Gustavo Padovan2d792812012-10-06 10:07:01 +0100386static int l2cap_sock_getsockopt_old(struct socket *sock, int optname,
387 char __user *optval, int __user *optlen)
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200388{
389 struct sock *sk = sock->sk;
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300390 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200391 struct l2cap_options opts;
392 struct l2cap_conninfo cinfo;
393 int len, err = 0;
394 u32 opt;
395
396 BT_DBG("sk %p", sk);
397
398 if (get_user(len, optlen))
399 return -EFAULT;
400
401 lock_sock(sk);
402
403 switch (optname) {
404 case L2CAP_OPTIONS:
Johan Hedberg64b4f8d2013-12-02 16:02:03 +0200405 /* LE sockets should use BT_SNDMTU/BT_RCVMTU, but since
406 * legacy ATT code depends on getsockopt for
407 * L2CAP_OPTIONS we need to let this pass.
408 */
409 if (bdaddr_type_is_le(chan->src_type) &&
410 chan->scid != L2CAP_CID_ATT) {
411 err = -EINVAL;
412 break;
413 }
414
Vasiliy Kulikove3fb5922011-02-10 20:59:42 +0300415 memset(&opts, 0, sizeof(opts));
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300416 opts.imtu = chan->imtu;
417 opts.omtu = chan->omtu;
418 opts.flush_to = chan->flush_to;
419 opts.mode = chan->mode;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -0300420 opts.fcs = chan->fcs;
421 opts.max_tx = chan->max_tx;
Andrei Emeltchenko6327eb92011-10-11 13:37:42 +0300422 opts.txwin_size = chan->tx_win;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200423
424 len = min_t(unsigned int, len, sizeof(opts));
425 if (copy_to_user(optval, (char *) &opts, len))
426 err = -EFAULT;
427
428 break;
429
430 case L2CAP_LM:
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300431 switch (chan->sec_level) {
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200432 case BT_SECURITY_LOW:
433 opt = L2CAP_LM_AUTH;
434 break;
435 case BT_SECURITY_MEDIUM:
436 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
437 break;
438 case BT_SECURITY_HIGH:
439 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
Gustavo Padovan2d792812012-10-06 10:07:01 +0100440 L2CAP_LM_SECURE;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200441 break;
Marcel Holtmann7d513e92014-01-15 22:37:40 -0800442 case BT_SECURITY_FIPS:
443 opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
444 L2CAP_LM_SECURE | L2CAP_LM_FIPS;
445 break;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200446 default:
447 opt = 0;
448 break;
449 }
450
Andrei Emeltchenko43bd0f32011-10-11 14:04:34 +0300451 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200452 opt |= L2CAP_LM_MASTER;
453
Andrei Emeltchenkoecf61bd2011-10-11 14:04:32 +0300454 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200455 opt |= L2CAP_LM_RELIABLE;
456
457 if (put_user(opt, (u32 __user *) optval))
458 err = -EFAULT;
Marcel Holtmann7d513e92014-01-15 22:37:40 -0800459
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200460 break;
461
462 case L2CAP_CONNINFO:
463 if (sk->sk_state != BT_CONNECTED &&
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300464 !(sk->sk_state == BT_CONNECT2 &&
465 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200466 err = -ENOTCONN;
467 break;
468 }
469
Filip Palian8d03e972011-05-12 19:32:46 +0200470 memset(&cinfo, 0, sizeof(cinfo));
Gustavo F. Padovan8c1d7872011-04-13 20:23:55 -0300471 cinfo.hci_handle = chan->conn->hcon->handle;
472 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200473
474 len = min_t(unsigned int, len, sizeof(cinfo));
475 if (copy_to_user(optval, (char *) &cinfo, len))
476 err = -EFAULT;
477
478 break;
479
480 default:
481 err = -ENOPROTOOPT;
482 break;
483 }
484
485 release_sock(sk);
486 return err;
487}
488
Gustavo Padovan2d792812012-10-06 10:07:01 +0100489static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname,
490 char __user *optval, int __user *optlen)
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200491{
492 struct sock *sk = sock->sk;
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300493 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200494 struct bt_security sec;
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700495 struct bt_power pwr;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200496 int len, err = 0;
497
498 BT_DBG("sk %p", sk);
499
500 if (level == SOL_L2CAP)
501 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
502
503 if (level != SOL_BLUETOOTH)
504 return -ENOPROTOOPT;
505
506 if (get_user(len, optlen))
507 return -EFAULT;
508
509 lock_sock(sk);
510
511 switch (optname) {
512 case BT_SECURITY:
Gustavo F. Padovan715ec002011-05-02 17:13:55 -0300513 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
Johan Hedberge0c888a2014-01-25 17:10:07 -0500514 chan->chan_type != L2CAP_CHAN_FIXED &&
Gustavo Padovan2d792812012-10-06 10:07:01 +0100515 chan->chan_type != L2CAP_CHAN_RAW) {
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200516 err = -EINVAL;
517 break;
518 }
519
Vinicius Costa Gomes8f360112011-07-08 18:31:46 -0300520 memset(&sec, 0, sizeof(sec));
Andrei Emeltchenko85e34362012-10-05 16:56:54 +0300521 if (chan->conn) {
Gustavo Padovanc6585a42012-05-07 03:07:26 -0300522 sec.level = chan->conn->hcon->sec_level;
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200523
Andrei Emeltchenko85e34362012-10-05 16:56:54 +0300524 if (sk->sk_state == BT_CONNECTED)
525 sec.key_size = chan->conn->hcon->enc_key_size;
526 } else {
527 sec.level = chan->sec_level;
528 }
Vinicius Costa Gomes8f360112011-07-08 18:31:46 -0300529
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200530 len = min_t(unsigned int, len, sizeof(sec));
531 if (copy_to_user(optval, (char *) &sec, len))
532 err = -EFAULT;
533
534 break;
535
536 case BT_DEFER_SETUP:
537 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
538 err = -EINVAL;
539 break;
540 }
541
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300542 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
543 (u32 __user *) optval))
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200544 err = -EFAULT;
545
546 break;
547
548 case BT_FLUSHABLE:
Andrei Emeltchenkod57b0e82011-10-11 14:04:31 +0300549 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
Gustavo Padovan2d792812012-10-06 10:07:01 +0100550 (u32 __user *) optval))
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200551 err = -EFAULT;
552
553 break;
554
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700555 case BT_POWER:
556 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
Gustavo Padovan2d792812012-10-06 10:07:01 +0100557 && sk->sk_type != SOCK_RAW) {
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700558 err = -EINVAL;
559 break;
560 }
561
Andrei Emeltchenko15770b12011-10-11 14:04:33 +0300562 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700563
564 len = min_t(unsigned int, len, sizeof(pwr));
565 if (copy_to_user(optval, (char *) &pwr, len))
566 err = -EFAULT;
567
568 break;
569
Mat Martineau2ea66482011-11-02 16:18:30 -0700570 case BT_CHANNEL_POLICY:
Mat Martineau2ea66482011-11-02 16:18:30 -0700571 if (put_user(chan->chan_policy, (u32 __user *) optval))
572 err = -EFAULT;
573 break;
574
Johan Hedberg1f435422013-12-02 16:34:18 +0200575 case BT_SNDMTU:
Johan Hedberg1f435422013-12-02 16:34:18 +0200576 if (!bdaddr_type_is_le(chan->src_type)) {
577 err = -EINVAL;
578 break;
579 }
580
581 if (sk->sk_state != BT_CONNECTED) {
582 err = -ENOTCONN;
583 break;
584 }
585
586 if (put_user(chan->omtu, (u16 __user *) optval))
587 err = -EFAULT;
588 break;
589
590 case BT_RCVMTU:
Johan Hedberg1f435422013-12-02 16:34:18 +0200591 if (!bdaddr_type_is_le(chan->src_type)) {
592 err = -EINVAL;
593 break;
594 }
595
596 if (put_user(chan->imtu, (u16 __user *) optval))
597 err = -EFAULT;
598 break;
599
Gustavo F. Padovan99f48082011-02-04 02:52:55 -0200600 default:
601 err = -ENOPROTOOPT;
602 break;
603 }
604
605 release_sock(sk);
606 return err;
607}
608
Andre Guedes682877c2012-05-31 17:01:34 -0300609static bool l2cap_valid_mtu(struct l2cap_chan *chan, u16 mtu)
610{
611 switch (chan->scid) {
Johan Hedberg073d1cf2013-04-29 19:35:35 +0300612 case L2CAP_CID_ATT:
Andre Guedes8c3a4f02012-05-31 17:01:35 -0300613 if (mtu < L2CAP_LE_MIN_MTU)
Andre Guedes682877c2012-05-31 17:01:34 -0300614 return false;
615 break;
616
617 default:
618 if (mtu < L2CAP_DEFAULT_MIN_MTU)
619 return false;
620 }
621
622 return true;
623}
624
Gustavo Padovan2d792812012-10-06 10:07:01 +0100625static int l2cap_sock_setsockopt_old(struct socket *sock, int optname,
626 char __user *optval, unsigned int optlen)
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200627{
628 struct sock *sk = sock->sk;
Gustavo F. Padovanb4450032011-04-12 18:15:09 -0300629 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200630 struct l2cap_options opts;
631 int len, err = 0;
632 u32 opt;
633
634 BT_DBG("sk %p", sk);
635
636 lock_sock(sk);
637
638 switch (optname) {
639 case L2CAP_OPTIONS:
Johan Hedberg64b4f8d2013-12-02 16:02:03 +0200640 if (bdaddr_type_is_le(chan->src_type)) {
641 err = -EINVAL;
642 break;
643 }
644
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200645 if (sk->sk_state == BT_CONNECTED) {
646 err = -EINVAL;
647 break;
648 }
649
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300650 opts.imtu = chan->imtu;
651 opts.omtu = chan->omtu;
652 opts.flush_to = chan->flush_to;
653 opts.mode = chan->mode;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -0300654 opts.fcs = chan->fcs;
655 opts.max_tx = chan->max_tx;
Andrei Emeltchenko6327eb92011-10-11 13:37:42 +0300656 opts.txwin_size = chan->tx_win;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200657
658 len = min_t(unsigned int, sizeof(opts), optlen);
659 if (copy_from_user((char *) &opts, optval, len)) {
660 err = -EFAULT;
661 break;
662 }
663
Andrei Emeltchenko6327eb92011-10-11 13:37:42 +0300664 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200665 err = -EINVAL;
666 break;
667 }
668
Andre Guedes682877c2012-05-31 17:01:34 -0300669 if (!l2cap_valid_mtu(chan, opts.imtu)) {
670 err = -EINVAL;
671 break;
672 }
673
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300674 chan->mode = opts.mode;
675 switch (chan->mode) {
Johan Hedberg38319712013-05-17 12:49:23 +0300676 case L2CAP_MODE_LE_FLOWCTL:
677 break;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200678 case L2CAP_MODE_BASIC:
Gustavo F. Padovanc1360a12011-06-10 17:02:12 -0300679 clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200680 break;
681 case L2CAP_MODE_ERTM:
682 case L2CAP_MODE_STREAMING:
683 if (!disable_ertm)
684 break;
685 /* fall through */
686 default:
687 err = -EINVAL;
688 break;
689 }
690
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300691 chan->imtu = opts.imtu;
692 chan->omtu = opts.omtu;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -0300693 chan->fcs = opts.fcs;
694 chan->max_tx = opts.max_tx;
Andrei Emeltchenko6327eb92011-10-11 13:37:42 +0300695 chan->tx_win = opts.txwin_size;
Andrei Emeltchenko12d59782012-10-10 17:38:26 +0300696 chan->flush_to = opts.flush_to;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200697 break;
698
699 case L2CAP_LM:
700 if (get_user(opt, (u32 __user *) optval)) {
701 err = -EFAULT;
702 break;
703 }
704
Marcel Holtmann7d513e92014-01-15 22:37:40 -0800705 if (opt & L2CAP_LM_FIPS) {
706 err = -EINVAL;
707 break;
708 }
709
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200710 if (opt & L2CAP_LM_AUTH)
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300711 chan->sec_level = BT_SECURITY_LOW;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200712 if (opt & L2CAP_LM_ENCRYPT)
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300713 chan->sec_level = BT_SECURITY_MEDIUM;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200714 if (opt & L2CAP_LM_SECURE)
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300715 chan->sec_level = BT_SECURITY_HIGH;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200716
Andrei Emeltchenko43bd0f32011-10-11 14:04:34 +0300717 if (opt & L2CAP_LM_MASTER)
718 set_bit(FLAG_ROLE_SWITCH, &chan->flags);
719 else
720 clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
Andrei Emeltchenkoecf61bd2011-10-11 14:04:32 +0300721
722 if (opt & L2CAP_LM_RELIABLE)
723 set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
724 else
725 clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200726 break;
727
728 default:
729 err = -ENOPROTOOPT;
730 break;
731 }
732
733 release_sock(sk);
734 return err;
735}
736
Gustavo Padovan2d792812012-10-06 10:07:01 +0100737static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
738 char __user *optval, unsigned int optlen)
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200739{
740 struct sock *sk = sock->sk;
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300741 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200742 struct bt_security sec;
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700743 struct bt_power pwr;
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300744 struct l2cap_conn *conn;
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200745 int len, err = 0;
746 u32 opt;
747
748 BT_DBG("sk %p", sk);
749
750 if (level == SOL_L2CAP)
751 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
752
753 if (level != SOL_BLUETOOTH)
754 return -ENOPROTOOPT;
755
756 lock_sock(sk);
757
758 switch (optname) {
759 case BT_SECURITY:
Gustavo F. Padovan715ec002011-05-02 17:13:55 -0300760 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
Johan Hedberge0c888a2014-01-25 17:10:07 -0500761 chan->chan_type != L2CAP_CHAN_FIXED &&
Gustavo Padovan2d792812012-10-06 10:07:01 +0100762 chan->chan_type != L2CAP_CHAN_RAW) {
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200763 err = -EINVAL;
764 break;
765 }
766
767 sec.level = BT_SECURITY_LOW;
768
769 len = min_t(unsigned int, sizeof(sec), optlen);
770 if (copy_from_user((char *) &sec, optval, len)) {
771 err = -EFAULT;
772 break;
773 }
774
775 if (sec.level < BT_SECURITY_LOW ||
Gustavo Padovan2d792812012-10-06 10:07:01 +0100776 sec.level > BT_SECURITY_HIGH) {
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200777 err = -EINVAL;
778 break;
779 }
780
Gustavo F. Padovan43434782011-04-12 18:31:57 -0300781 chan->sec_level = sec.level;
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300782
Gustavo F. Padovan0bee1d62011-11-05 19:58:31 -0200783 if (!chan->conn)
784 break;
785
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300786 conn = chan->conn;
Gustavo F. Padovan0bee1d62011-11-05 19:58:31 -0200787
788 /*change security for LE channels */
Johan Hedberg073d1cf2013-04-29 19:35:35 +0300789 if (chan->scid == L2CAP_CID_ATT) {
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300790 if (!conn->hcon->out) {
791 err = -EINVAL;
792 break;
793 }
794
Vinicius Costa Gomescc110922012-08-23 21:32:43 -0300795 if (smp_conn_security(conn->hcon, sec.level))
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300796 break;
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300797 sk->sk_state = BT_CONFIG;
Gustavo F. Padovan3542b8542011-12-28 13:54:17 -0200798 chan->state = BT_CONFIG;
Gustavo F. Padovan0bee1d62011-11-05 19:58:31 -0200799
Gustavo Padovana7d77232012-05-13 03:20:07 -0300800 /* or for ACL link */
801 } else if ((sk->sk_state == BT_CONNECT2 &&
Gustavo Padovan2d792812012-10-06 10:07:01 +0100802 test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) ||
Gustavo Padovana7d77232012-05-13 03:20:07 -0300803 sk->sk_state == BT_CONNECTED) {
804 if (!l2cap_chan_check_security(chan))
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300805 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
Gustavo Padovana7d77232012-05-13 03:20:07 -0300806 else
807 sk->sk_state_change(sk);
Gustavo F. Padovan0bee1d62011-11-05 19:58:31 -0200808 } else {
809 err = -EINVAL;
Vinicius Costa Gomesf1cb9af2011-01-26 21:42:57 -0300810 }
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200811 break;
812
813 case BT_DEFER_SETUP:
814 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
815 err = -EINVAL;
816 break;
817 }
818
819 if (get_user(opt, (u32 __user *) optval)) {
820 err = -EFAULT;
821 break;
822 }
823
Marcel Holtmannbdc25782013-10-14 02:45:34 -0700824 if (opt) {
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300825 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
Marcel Holtmannbdc25782013-10-14 02:45:34 -0700826 set_bit(FLAG_DEFER_SETUP, &chan->flags);
827 } else {
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300828 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
Marcel Holtmannbdc25782013-10-14 02:45:34 -0700829 clear_bit(FLAG_DEFER_SETUP, &chan->flags);
830 }
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200831 break;
832
833 case BT_FLUSHABLE:
834 if (get_user(opt, (u32 __user *) optval)) {
835 err = -EFAULT;
836 break;
837 }
838
839 if (opt > BT_FLUSHABLE_ON) {
840 err = -EINVAL;
841 break;
842 }
843
844 if (opt == BT_FLUSHABLE_OFF) {
Johannes Bergc1f23a22013-10-07 18:19:16 +0200845 conn = chan->conn;
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300846 /* proceed further only when we have l2cap_conn and
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200847 No Flush support in the LM */
848 if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
849 err = -EINVAL;
850 break;
851 }
852 }
853
Andrei Emeltchenkod57b0e82011-10-11 14:04:31 +0300854 if (opt)
855 set_bit(FLAG_FLUSHABLE, &chan->flags);
856 else
857 clear_bit(FLAG_FLUSHABLE, &chan->flags);
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200858 break;
859
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700860 case BT_POWER:
861 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
Gustavo Padovan2d792812012-10-06 10:07:01 +0100862 chan->chan_type != L2CAP_CHAN_RAW) {
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700863 err = -EINVAL;
864 break;
865 }
866
867 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
868
869 len = min_t(unsigned int, sizeof(pwr), optlen);
870 if (copy_from_user((char *) &pwr, optval, len)) {
871 err = -EFAULT;
872 break;
873 }
Andrei Emeltchenko15770b12011-10-11 14:04:33 +0300874
875 if (pwr.force_active)
876 set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
877 else
878 clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
Jaikumar Ganesh14b12d02011-05-23 18:06:04 -0700879 break;
880
Mat Martineau2ea66482011-11-02 16:18:30 -0700881 case BT_CHANNEL_POLICY:
Mat Martineau2ea66482011-11-02 16:18:30 -0700882 if (get_user(opt, (u32 __user *) optval)) {
883 err = -EFAULT;
884 break;
885 }
886
887 if (opt > BT_CHANNEL_POLICY_AMP_PREFERRED) {
888 err = -EINVAL;
889 break;
890 }
891
892 if (chan->mode != L2CAP_MODE_ERTM &&
Gustavo Padovan2d792812012-10-06 10:07:01 +0100893 chan->mode != L2CAP_MODE_STREAMING) {
Mat Martineau2ea66482011-11-02 16:18:30 -0700894 err = -EOPNOTSUPP;
895 break;
896 }
897
898 chan->chan_policy = (u8) opt;
Mat Martineau3f7a56c2012-10-23 15:24:23 -0700899
900 if (sk->sk_state == BT_CONNECTED &&
901 chan->move_role == L2CAP_MOVE_ROLE_NONE)
902 l2cap_move_start(chan);
903
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200904 break;
905
Johan Hedberg1f435422013-12-02 16:34:18 +0200906 case BT_SNDMTU:
Johan Hedberg1f435422013-12-02 16:34:18 +0200907 if (!bdaddr_type_is_le(chan->src_type)) {
908 err = -EINVAL;
909 break;
910 }
911
912 /* Setting is not supported as it's the remote side that
913 * decides this.
914 */
915 err = -EPERM;
916 break;
917
918 case BT_RCVMTU:
Johan Hedberg1f435422013-12-02 16:34:18 +0200919 if (!bdaddr_type_is_le(chan->src_type)) {
920 err = -EINVAL;
921 break;
922 }
923
924 if (sk->sk_state == BT_CONNECTED) {
925 err = -EISCONN;
926 break;
927 }
928
929 if (get_user(opt, (u32 __user *) optval)) {
930 err = -EFAULT;
931 break;
932 }
933
934 chan->imtu = opt;
935 break;
936
Gustavo F. Padovan33575df2011-02-04 02:48:48 -0200937 default:
938 err = -ENOPROTOOPT;
939 break;
940 }
941
942 release_sock(sk);
943 return err;
944}
945
Gustavo Padovan2d792812012-10-06 10:07:01 +0100946static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
947 struct msghdr *msg, size_t len)
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200948{
949 struct sock *sk = sock->sk;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -0300950 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200951 int err;
952
953 BT_DBG("sock %p, sk %p", sock, sk);
954
955 err = sock_error(sk);
956 if (err)
957 return err;
958
959 if (msg->msg_flags & MSG_OOB)
960 return -EOPNOTSUPP;
961
Mat Martineaua6a55682012-05-04 14:20:31 -0700962 if (sk->sk_state != BT_CONNECTED)
Gustavo F. Padovan9a91a042011-04-28 18:50:17 -0300963 return -ENOTCONN;
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200964
Johan Hedberge793dcf2013-09-16 13:05:19 +0300965 lock_sock(sk);
966 err = bt_sock_wait_ready(sk, msg->msg_flags);
967 release_sock(sk);
968 if (err)
969 return err;
970
Mat Martineaua6a55682012-05-04 14:20:31 -0700971 l2cap_chan_lock(chan);
Luiz Augusto von Dentz5e59b792011-11-01 10:58:57 +0200972 err = l2cap_chan_send(chan, msg, len, sk->sk_priority);
Mat Martineaua6a55682012-05-04 14:20:31 -0700973 l2cap_chan_unlock(chan);
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200974
Gustavo F. Padovanfd83ccd2011-02-04 03:20:52 -0200975 return err;
976}
977
Gustavo Padovan2d792812012-10-06 10:07:01 +0100978static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
979 struct msghdr *msg, size_t len, int flags)
Gustavo F. Padovan68983252011-02-04 03:02:31 -0200980{
981 struct sock *sk = sock->sk;
Mat Martineaue3281402011-07-07 09:39:02 -0700982 struct l2cap_pinfo *pi = l2cap_pi(sk);
983 int err;
Gustavo F. Padovan68983252011-02-04 03:02:31 -0200984
985 lock_sock(sk);
986
Gustavo Padovanc5daa682012-05-16 12:17:10 -0300987 if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
988 &bt_sk(sk)->flags)) {
Johan Hedberg38319712013-05-17 12:49:23 +0300989 if (bdaddr_type_is_le(pi->chan->src_type)) {
990 sk->sk_state = BT_CONNECTED;
991 pi->chan->state = BT_CONNECTED;
992 __l2cap_le_connect_rsp_defer(pi->chan);
993 } else {
994 sk->sk_state = BT_CONFIG;
995 pi->chan->state = BT_CONFIG;
996 __l2cap_connect_rsp_defer(pi->chan);
997 }
Gustavo F. Padovan8c1d7872011-04-13 20:23:55 -0300998
Johan Hedberg970871b2013-09-25 13:26:05 +0300999 err = 0;
1000 goto done;
Gustavo F. Padovan68983252011-02-04 03:02:31 -02001001 }
1002
1003 release_sock(sk);
1004
1005 if (sock->type == SOCK_STREAM)
Mat Martineaue3281402011-07-07 09:39:02 -07001006 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
1007 else
1008 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
Gustavo F. Padovan68983252011-02-04 03:02:31 -02001009
Mat Martineaue3281402011-07-07 09:39:02 -07001010 if (pi->chan->mode != L2CAP_MODE_ERTM)
1011 return err;
1012
1013 /* Attempt to put pending rx data in the socket buffer */
1014
1015 lock_sock(sk);
1016
1017 if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
1018 goto done;
1019
1020 if (pi->rx_busy_skb) {
1021 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
1022 pi->rx_busy_skb = NULL;
1023 else
1024 goto done;
1025 }
1026
1027 /* Restore data flow when half of the receive buffer is
1028 * available. This avoids resending large numbers of
1029 * frames.
1030 */
1031 if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
1032 l2cap_chan_busy(pi->chan, 0);
1033
1034done:
1035 release_sock(sk);
1036 return err;
Gustavo F. Padovan68983252011-02-04 03:02:31 -02001037}
1038
Gustavo F. Padovan05fc1572011-02-04 03:26:01 -02001039/* Kill socket (only if zapped and orphan)
1040 * Must be called on unlocked socket.
1041 */
Gustavo F. Padovanba3bd0e2011-05-16 18:23:24 -03001042static void l2cap_sock_kill(struct sock *sk)
Gustavo F. Padovan05fc1572011-02-04 03:26:01 -02001043{
1044 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
1045 return;
1046
Andrei Emeltchenkoe05dcc32012-02-17 11:40:56 +02001047 BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
Gustavo F. Padovan05fc1572011-02-04 03:26:01 -02001048
1049 /* Kill poor orphan */
Gustavo F. Padovan6ff5abb2011-04-25 15:10:41 -03001050
Jaganath Kanakkassery4af66c62012-07-13 18:17:55 +05301051 l2cap_chan_put(l2cap_pi(sk)->chan);
Gustavo F. Padovan05fc1572011-02-04 03:26:01 -02001052 sock_set_flag(sk, SOCK_DEAD);
1053 sock_put(sk);
1054}
1055
Gustavo Padovandc253062013-10-15 19:24:49 -03001056static int __l2cap_wait_ack(struct sock *sk)
1057{
1058 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1059 DECLARE_WAITQUEUE(wait, current);
1060 int err = 0;
1061 int timeo = HZ/5;
1062
1063 add_wait_queue(sk_sleep(sk), &wait);
1064 set_current_state(TASK_INTERRUPTIBLE);
1065 while (chan->unacked_frames > 0 && chan->conn) {
1066 if (!timeo)
1067 timeo = HZ/5;
1068
1069 if (signal_pending(current)) {
1070 err = sock_intr_errno(timeo);
1071 break;
1072 }
1073
1074 release_sock(sk);
1075 timeo = schedule_timeout(timeo);
1076 lock_sock(sk);
1077 set_current_state(TASK_INTERRUPTIBLE);
1078
1079 err = sock_error(sk);
1080 if (err)
1081 break;
1082 }
1083 set_current_state(TASK_RUNNING);
1084 remove_wait_queue(sk_sleep(sk), &wait);
1085 return err;
1086}
1087
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001088static int l2cap_sock_shutdown(struct socket *sock, int how)
1089{
1090 struct sock *sk = sock->sk;
Andrei Emeltchenko7ddb6e02012-02-14 15:12:57 +02001091 struct l2cap_chan *chan;
Andrei Emeltchenko3df91ea2012-02-21 12:54:55 +02001092 struct l2cap_conn *conn;
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001093 int err = 0;
1094
1095 BT_DBG("sock %p, sk %p", sock, sk);
1096
1097 if (!sk)
1098 return 0;
1099
Andrei Emeltchenko7ddb6e02012-02-14 15:12:57 +02001100 chan = l2cap_pi(sk)->chan;
Andrei Emeltchenko3df91ea2012-02-21 12:54:55 +02001101 conn = chan->conn;
1102
1103 if (conn)
1104 mutex_lock(&conn->chan_lock);
Andrei Emeltchenko7ddb6e02012-02-14 15:12:57 +02001105
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001106 l2cap_chan_lock(chan);
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001107 lock_sock(sk);
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001108
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001109 if (!sk->sk_shutdown) {
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001110 if (chan->mode == L2CAP_MODE_ERTM)
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001111 err = __l2cap_wait_ack(sk);
1112
1113 sk->sk_shutdown = SHUTDOWN_MASK;
Andrei Emeltchenko3df91ea2012-02-21 12:54:55 +02001114
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001115 release_sock(sk);
Gustavo F. Padovan0f852722011-05-04 19:42:50 -03001116 l2cap_chan_close(chan, 0);
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001117 lock_sock(sk);
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001118
1119 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
1120 err = bt_sock_wait_state(sk, BT_CLOSED,
Gustavo Padovan2d792812012-10-06 10:07:01 +01001121 sk->sk_lingertime);
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001122 }
1123
1124 if (!err && sk->sk_err)
1125 err = -sk->sk_err;
1126
1127 release_sock(sk);
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001128 l2cap_chan_unlock(chan);
Andrei Emeltchenko3df91ea2012-02-21 12:54:55 +02001129
1130 if (conn)
1131 mutex_unlock(&conn->chan_lock);
1132
Gustavo F. Padovandcba0db2011-02-04 03:08:36 -02001133 return err;
1134}
1135
Gustavo F. Padovan554f05b2011-02-04 02:36:42 -02001136static int l2cap_sock_release(struct socket *sock)
1137{
1138 struct sock *sk = sock->sk;
1139 int err;
1140
1141 BT_DBG("sock %p, sk %p", sock, sk);
1142
1143 if (!sk)
1144 return 0;
1145
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001146 bt_sock_unlink(&l2cap_sk_list, sk);
1147
Gustavo F. Padovan554f05b2011-02-04 02:36:42 -02001148 err = l2cap_sock_shutdown(sock, 2);
1149
1150 sock_orphan(sk);
1151 l2cap_sock_kill(sk);
1152 return err;
1153}
1154
Andrei Emeltchenkoc0df7f62012-05-27 22:27:52 -03001155static void l2cap_sock_cleanup_listen(struct sock *parent)
1156{
1157 struct sock *sk;
1158
1159 BT_DBG("parent %p", parent);
1160
1161 /* Close not yet accepted channels */
1162 while ((sk = bt_accept_dequeue(parent, NULL))) {
1163 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1164
1165 l2cap_chan_lock(chan);
1166 __clear_chan_timer(chan);
1167 l2cap_chan_close(chan, ECONNRESET);
1168 l2cap_chan_unlock(chan);
1169
1170 l2cap_sock_kill(sk);
1171 }
1172}
1173
Gustavo Padovan80b98022012-05-27 22:27:51 -03001174static struct l2cap_chan *l2cap_sock_new_connection_cb(struct l2cap_chan *chan)
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001175{
Gustavo Padovan80b98022012-05-27 22:27:51 -03001176 struct sock *sk, *parent = chan->data;
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001177
Gustavo Padovan8ffb9292013-10-21 14:21:41 -02001178 lock_sock(parent);
1179
Gustavo Padovan53826692012-05-27 22:27:55 -03001180 /* Check for backlog size */
1181 if (sk_acceptq_is_full(parent)) {
1182 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1183 return NULL;
1184 }
1185
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001186 sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
Gustavo Padovan2d792812012-10-06 10:07:01 +01001187 GFP_ATOMIC);
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001188 if (!sk)
1189 return NULL;
1190
Octavian Purdilad22015a2012-01-22 00:28:34 +02001191 bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
1192
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001193 l2cap_sock_init(sk, parent);
1194
Gustavo Padovan644912e2012-10-12 19:35:23 +08001195 bt_accept_enqueue(parent, sk);
1196
Gustavo Padovan8ffb9292013-10-21 14:21:41 -02001197 release_sock(parent);
1198
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001199 return l2cap_pi(sk)->chan;
1200}
1201
Gustavo Padovan80b98022012-05-27 22:27:51 -03001202static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
Gustavo F. Padovan23070492011-05-16 17:57:22 -03001203{
Gustavo Padovan80b98022012-05-27 22:27:51 -03001204 struct sock *sk = chan->data;
Marcel Holtmann84b34d92013-10-13 11:36:07 -07001205 int err;
Gustavo F. Padovan23070492011-05-16 17:57:22 -03001206
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001207 lock_sock(sk);
1208
Marcel Holtmann84b34d92013-10-13 11:36:07 -07001209 if (l2cap_pi(sk)->rx_busy_skb) {
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001210 err = -ENOMEM;
1211 goto done;
1212 }
Mat Martineaue3281402011-07-07 09:39:02 -07001213
1214 err = sock_queue_rcv_skb(sk, skb);
1215
1216 /* For ERTM, handle one skb that doesn't fit into the recv
1217 * buffer. This is important to do because the data frames
1218 * have already been acked, so the skb cannot be discarded.
1219 *
1220 * Notify the l2cap core that the buffer is full, so the
1221 * LOCAL_BUSY state is entered and no more frames are
1222 * acked and reassembled until there is buffer space
1223 * available.
1224 */
Marcel Holtmann84b34d92013-10-13 11:36:07 -07001225 if (err < 0 && chan->mode == L2CAP_MODE_ERTM) {
1226 l2cap_pi(sk)->rx_busy_skb = skb;
1227 l2cap_chan_busy(chan, 1);
Mat Martineaue3281402011-07-07 09:39:02 -07001228 err = 0;
1229 }
1230
Andrei Emeltchenko6be36552012-02-22 17:11:56 +02001231done:
1232 release_sock(sk);
1233
Mat Martineaue3281402011-07-07 09:39:02 -07001234 return err;
Gustavo F. Padovan23070492011-05-16 17:57:22 -03001235}
1236
Gustavo Padovan80b98022012-05-27 22:27:51 -03001237static void l2cap_sock_close_cb(struct l2cap_chan *chan)
Gustavo F. Padovanba3bd0e2011-05-16 18:23:24 -03001238{
Gustavo Padovan80b98022012-05-27 22:27:51 -03001239 struct sock *sk = chan->data;
Gustavo F. Padovanba3bd0e2011-05-16 18:23:24 -03001240
1241 l2cap_sock_kill(sk);
1242}
1243
Andrei Emeltchenkoc0df7f62012-05-27 22:27:52 -03001244static void l2cap_sock_teardown_cb(struct l2cap_chan *chan, int err)
1245{
1246 struct sock *sk = chan->data;
1247 struct sock *parent;
1248
1249 lock_sock(sk);
1250
1251 parent = bt_sk(sk)->parent;
1252
1253 sock_set_flag(sk, SOCK_ZAPPED);
1254
1255 switch (chan->state) {
1256 case BT_OPEN:
1257 case BT_BOUND:
1258 case BT_CLOSED:
1259 break;
1260 case BT_LISTEN:
1261 l2cap_sock_cleanup_listen(sk);
1262 sk->sk_state = BT_CLOSED;
1263 chan->state = BT_CLOSED;
1264
1265 break;
1266 default:
1267 sk->sk_state = BT_CLOSED;
1268 chan->state = BT_CLOSED;
1269
1270 sk->sk_err = err;
1271
1272 if (parent) {
1273 bt_accept_unlink(sk);
David S. Miller676d2362014-04-11 16:15:36 -04001274 parent->sk_data_ready(parent);
Andrei Emeltchenkoc0df7f62012-05-27 22:27:52 -03001275 } else {
1276 sk->sk_state_change(sk);
1277 }
1278
1279 break;
1280 }
1281
1282 release_sock(sk);
1283}
1284
Gustavo Padovan53f52122013-10-15 19:24:45 -03001285static void l2cap_sock_state_change_cb(struct l2cap_chan *chan, int state,
1286 int err)
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -03001287{
Gustavo Padovan80b98022012-05-27 22:27:51 -03001288 struct sock *sk = chan->data;
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -03001289
1290 sk->sk_state = state;
Gustavo Padovan53f52122013-10-15 19:24:45 -03001291
1292 if (err)
1293 sk->sk_err = err;
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -03001294}
1295
Andrei Emeltchenko2f7719c2012-01-20 14:08:03 +02001296static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
Gustavo Padovan90338942012-04-06 20:15:47 -03001297 unsigned long len, int nb)
Andrei Emeltchenko2f7719c2012-01-20 14:08:03 +02001298{
Gustavo Padovan0f2c6152013-10-21 14:21:38 -02001299 struct sock *sk = chan->data;
Gustavo Padovan90338942012-04-06 20:15:47 -03001300 struct sk_buff *skb;
1301 int err;
Andrei Emeltchenko2f7719c2012-01-20 14:08:03 +02001302
Mat Martineaua6a55682012-05-04 14:20:31 -07001303 l2cap_chan_unlock(chan);
Gustavo Padovan0f2c6152013-10-21 14:21:38 -02001304 skb = bt_skb_send_alloc(sk, len, nb, &err);
Mat Martineaua6a55682012-05-04 14:20:31 -07001305 l2cap_chan_lock(chan);
1306
Gustavo Padovan90338942012-04-06 20:15:47 -03001307 if (!skb)
1308 return ERR_PTR(err);
1309
Gustavo Padovan0e790c62013-10-21 18:22:24 -02001310 bt_cb(skb)->chan = chan;
1311
Gustavo Padovan90338942012-04-06 20:15:47 -03001312 return skb;
Andrei Emeltchenko2f7719c2012-01-20 14:08:03 +02001313}
1314
Andrei Emeltchenko54a59aa2012-05-27 22:27:53 -03001315static void l2cap_sock_ready_cb(struct l2cap_chan *chan)
1316{
1317 struct sock *sk = chan->data;
1318 struct sock *parent;
1319
1320 lock_sock(sk);
1321
1322 parent = bt_sk(sk)->parent;
1323
1324 BT_DBG("sk %p, parent %p", sk, parent);
1325
1326 sk->sk_state = BT_CONNECTED;
1327 sk->sk_state_change(sk);
1328
1329 if (parent)
David S. Miller676d2362014-04-11 16:15:36 -04001330 parent->sk_data_ready(parent);
Andrei Emeltchenko54a59aa2012-05-27 22:27:53 -03001331
1332 release_sock(sk);
1333}
1334
Gustavo Padovan2dc4e512012-10-12 19:35:24 +08001335static void l2cap_sock_defer_cb(struct l2cap_chan *chan)
1336{
Gustavo Padovanacdcabf2013-10-21 14:21:39 -02001337 struct sock *parent, *sk = chan->data;
Gustavo Padovan2dc4e512012-10-12 19:35:24 +08001338
Gustavo Padovanacdcabf2013-10-21 14:21:39 -02001339 lock_sock(sk);
1340
1341 parent = bt_sk(sk)->parent;
Gustavo Padovan2dc4e512012-10-12 19:35:24 +08001342 if (parent)
David S. Miller676d2362014-04-11 16:15:36 -04001343 parent->sk_data_ready(parent);
Gustavo Padovanacdcabf2013-10-21 14:21:39 -02001344
1345 release_sock(sk);
Gustavo Padovan2dc4e512012-10-12 19:35:24 +08001346}
1347
Marcel Holtmannd97c8992013-10-14 02:53:54 -07001348static void l2cap_sock_resume_cb(struct l2cap_chan *chan)
1349{
1350 struct sock *sk = chan->data;
1351
1352 clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1353 sk->sk_state_change(sk);
1354}
1355
Gustavo Padovan5ec1bbe2013-10-15 19:24:48 -03001356static void l2cap_sock_set_shutdown_cb(struct l2cap_chan *chan)
1357{
1358 struct sock *sk = chan->data;
1359
1360 lock_sock(sk);
1361 sk->sk_shutdown = SHUTDOWN_MASK;
1362 release_sock(sk);
1363}
1364
Gustavo Padovan8d836d72013-10-15 19:24:47 -03001365static long l2cap_sock_get_sndtimeo_cb(struct l2cap_chan *chan)
1366{
1367 struct sock *sk = chan->data;
1368
1369 return sk->sk_sndtimeo;
1370}
1371
Johan Hedberg837776f2013-10-15 11:03:18 +03001372static void l2cap_sock_suspend_cb(struct l2cap_chan *chan)
1373{
1374 struct sock *sk = chan->data;
1375
1376 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1377 sk->sk_state_change(sk);
1378}
1379
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001380static struct l2cap_ops l2cap_chan_ops = {
1381 .name = "L2CAP Socket Interface",
1382 .new_connection = l2cap_sock_new_connection_cb,
Gustavo F. Padovan23070492011-05-16 17:57:22 -03001383 .recv = l2cap_sock_recv_cb,
Gustavo F. Padovanba3bd0e2011-05-16 18:23:24 -03001384 .close = l2cap_sock_close_cb,
Andrei Emeltchenkoc0df7f62012-05-27 22:27:52 -03001385 .teardown = l2cap_sock_teardown_cb,
Gustavo F. Padovan89bc5002011-06-03 00:19:47 -03001386 .state_change = l2cap_sock_state_change_cb,
Andrei Emeltchenko54a59aa2012-05-27 22:27:53 -03001387 .ready = l2cap_sock_ready_cb,
Gustavo Padovan2dc4e512012-10-12 19:35:24 +08001388 .defer = l2cap_sock_defer_cb,
Marcel Holtmannd97c8992013-10-14 02:53:54 -07001389 .resume = l2cap_sock_resume_cb,
Johan Hedberg837776f2013-10-15 11:03:18 +03001390 .suspend = l2cap_sock_suspend_cb,
Gustavo Padovan5ec1bbe2013-10-15 19:24:48 -03001391 .set_shutdown = l2cap_sock_set_shutdown_cb,
Gustavo Padovan8d836d72013-10-15 19:24:47 -03001392 .get_sndtimeo = l2cap_sock_get_sndtimeo_cb,
Andrei Emeltchenko2f7719c2012-01-20 14:08:03 +02001393 .alloc_skb = l2cap_sock_alloc_skb_cb,
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001394};
1395
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001396static void l2cap_sock_destruct(struct sock *sk)
1397{
1398 BT_DBG("sk %p", sk);
1399
Sasha Levin23d3a862012-10-08 16:48:32 -04001400 if (l2cap_pi(sk)->chan)
1401 l2cap_chan_put(l2cap_pi(sk)->chan);
Marcel Holtmann84b34d92013-10-13 11:36:07 -07001402
Mat Martineaue3281402011-07-07 09:39:02 -07001403 if (l2cap_pi(sk)->rx_busy_skb) {
1404 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
1405 l2cap_pi(sk)->rx_busy_skb = NULL;
1406 }
1407
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001408 skb_queue_purge(&sk->sk_receive_queue);
1409 skb_queue_purge(&sk->sk_write_queue);
1410}
1411
Marcel Holtmann2edf8702013-10-13 12:55:29 -07001412static void l2cap_skb_msg_name(struct sk_buff *skb, void *msg_name,
1413 int *msg_namelen)
1414{
Steffen Hurrle342dfc32014-01-17 22:53:15 +01001415 DECLARE_SOCKADDR(struct sockaddr_l2 *, la, msg_name);
Marcel Holtmann2edf8702013-10-13 12:55:29 -07001416
1417 memset(la, 0, sizeof(struct sockaddr_l2));
1418 la->l2_family = AF_BLUETOOTH;
1419 la->l2_psm = bt_cb(skb)->psm;
1420 bacpy(&la->l2_bdaddr, &bt_cb(skb)->bdaddr);
1421
1422 *msg_namelen = sizeof(struct sockaddr_l2);
1423}
1424
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001425static void l2cap_sock_init(struct sock *sk, struct sock *parent)
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001426{
Marcel Holtmann84b34d92013-10-13 11:36:07 -07001427 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001428
1429 BT_DBG("sk %p", sk);
1430
1431 if (parent) {
Gustavo F. Padovanb4450032011-04-12 18:15:09 -03001432 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1433
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001434 sk->sk_type = parent->sk_type;
Gustavo Padovanc5daa682012-05-16 12:17:10 -03001435 bt_sk(sk)->flags = bt_sk(parent)->flags;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001436
Gustavo F. Padovan715ec002011-05-02 17:13:55 -03001437 chan->chan_type = pchan->chan_type;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001438 chan->imtu = pchan->imtu;
1439 chan->omtu = pchan->omtu;
Gustavo F. Padovanb4450032011-04-12 18:15:09 -03001440 chan->conf_state = pchan->conf_state;
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001441 chan->mode = pchan->mode;
Gustavo F. Padovan47d1ec62011-04-13 15:57:03 -03001442 chan->fcs = pchan->fcs;
1443 chan->max_tx = pchan->max_tx;
1444 chan->tx_win = pchan->tx_win;
Andrei Emeltchenko6b3c7102011-11-02 09:57:10 +02001445 chan->tx_win_max = pchan->tx_win_max;
Gustavo F. Padovan43434782011-04-12 18:31:57 -03001446 chan->sec_level = pchan->sec_level;
Andrei Emeltchenkod57b0e82011-10-11 14:04:31 +03001447 chan->flags = pchan->flags;
Johan Hedberg0cd75f72013-05-17 13:09:05 +03001448 chan->tx_credits = pchan->tx_credits;
1449 chan->rx_credits = pchan->rx_credits;
Paul Moore6230c9b2011-10-07 09:40:59 +00001450
Johan Hedberg7a8e5a32014-01-25 17:10:09 -05001451 if (chan->chan_type == L2CAP_CHAN_FIXED) {
1452 chan->scid = pchan->scid;
1453 chan->dcid = pchan->scid;
1454 }
1455
Paul Moore6230c9b2011-10-07 09:40:59 +00001456 security_sk_clone(parent, sk);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001457 } else {
Gustavo F. Padovan715ec002011-05-02 17:13:55 -03001458 switch (sk->sk_type) {
1459 case SOCK_RAW:
1460 chan->chan_type = L2CAP_CHAN_RAW;
1461 break;
1462 case SOCK_DGRAM:
1463 chan->chan_type = L2CAP_CHAN_CONN_LESS;
Marcel Holtmann2edf8702013-10-13 12:55:29 -07001464 bt_sk(sk)->skb_msg_name = l2cap_skb_msg_name;
Gustavo F. Padovan715ec002011-05-02 17:13:55 -03001465 break;
1466 case SOCK_SEQPACKET:
1467 case SOCK_STREAM:
1468 chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1469 break;
1470 }
1471
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001472 chan->imtu = L2CAP_DEFAULT_MTU;
1473 chan->omtu = 0;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001474 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001475 chan->mode = L2CAP_MODE_ERTM;
Gustavo F. Padovanc1360a12011-06-10 17:02:12 -03001476 set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001477 } else {
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001478 chan->mode = L2CAP_MODE_BASIC;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001479 }
Andrei Emeltchenkobd4b1652012-03-28 16:31:25 +03001480
1481 l2cap_chan_set_defaults(chan);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001482 }
1483
1484 /* Default config options */
Gustavo F. Padovan0c1bc5c2011-04-13 17:20:49 -03001485 chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
Gustavo F. Padovan80808e42011-05-16 17:24:37 -03001486
1487 chan->data = sk;
1488 chan->ops = &l2cap_chan_ops;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001489}
1490
1491static struct proto l2cap_proto = {
1492 .name = "L2CAP",
1493 .owner = THIS_MODULE,
1494 .obj_size = sizeof(struct l2cap_pinfo)
1495};
1496
Gustavo Padovan2d792812012-10-06 10:07:01 +01001497static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
1498 int proto, gfp_t prio)
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001499{
1500 struct sock *sk;
Gustavo F. Padovandc50a062011-05-16 16:42:01 -03001501 struct l2cap_chan *chan;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001502
1503 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1504 if (!sk)
1505 return NULL;
1506
1507 sock_init_data(sock, sk);
1508 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1509
1510 sk->sk_destruct = l2cap_sock_destruct;
Marcel Holtmannba13ccd2012-03-01 14:25:33 -08001511 sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001512
1513 sock_reset_flag(sk, SOCK_ZAPPED);
1514
1515 sk->sk_protocol = proto;
1516 sk->sk_state = BT_OPEN;
1517
Gustavo Padovaneef1d9b2012-03-25 13:59:16 -03001518 chan = l2cap_chan_create();
Gustavo F. Padovandc50a062011-05-16 16:42:01 -03001519 if (!chan) {
Jaganath Kanakkassery49dfbb92012-07-19 12:54:04 +05301520 sk_free(sk);
Gustavo F. Padovandc50a062011-05-16 16:42:01 -03001521 return NULL;
1522 }
1523
Mat Martineau61d6ef32012-04-27 16:50:50 -07001524 l2cap_chan_hold(chan);
1525
Gustavo F. Padovandc50a062011-05-16 16:42:01 -03001526 l2cap_pi(sk)->chan = chan;
1527
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001528 return sk;
1529}
1530
1531static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1532 int kern)
1533{
1534 struct sock *sk;
1535
1536 BT_DBG("sock %p", sock);
1537
1538 sock->state = SS_UNCONNECTED;
1539
1540 if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
Gustavo Padovan2d792812012-10-06 10:07:01 +01001541 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001542 return -ESOCKTNOSUPPORT;
1543
1544 if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1545 return -EPERM;
1546
1547 sock->ops = &l2cap_sock_ops;
1548
1549 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1550 if (!sk)
1551 return -ENOMEM;
1552
1553 l2cap_sock_init(sk, NULL);
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001554 bt_sock_link(&l2cap_sk_list, sk);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001555 return 0;
1556}
1557
Gustavo F. Padovancf2f90f2011-04-27 18:40:39 -03001558static const struct proto_ops l2cap_sock_ops = {
Gustavo F. Padovan65390582011-02-04 02:33:56 -02001559 .family = PF_BLUETOOTH,
1560 .owner = THIS_MODULE,
1561 .release = l2cap_sock_release,
1562 .bind = l2cap_sock_bind,
1563 .connect = l2cap_sock_connect,
1564 .listen = l2cap_sock_listen,
1565 .accept = l2cap_sock_accept,
1566 .getname = l2cap_sock_getname,
1567 .sendmsg = l2cap_sock_sendmsg,
1568 .recvmsg = l2cap_sock_recvmsg,
1569 .poll = bt_sock_poll,
1570 .ioctl = bt_sock_ioctl,
1571 .mmap = sock_no_mmap,
1572 .socketpair = sock_no_socketpair,
1573 .shutdown = l2cap_sock_shutdown,
1574 .setsockopt = l2cap_sock_setsockopt,
1575 .getsockopt = l2cap_sock_getsockopt
1576};
1577
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001578static const struct net_proto_family l2cap_sock_family_ops = {
1579 .family = PF_BLUETOOTH,
1580 .owner = THIS_MODULE,
1581 .create = l2cap_sock_create,
1582};
1583
1584int __init l2cap_init_sockets(void)
1585{
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001586 int err;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001587
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001588 err = proto_register(&l2cap_proto, 0);
1589 if (err < 0)
1590 return err;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001591
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001592 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001593 if (err < 0) {
1594 BT_ERR("L2CAP socket registration failed");
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001595 goto error;
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001596 }
1597
Al Virob0316612013-04-04 19:14:33 -04001598 err = bt_procfs_init(&init_net, "l2cap", &l2cap_sk_list,
Gustavo Padovan2d792812012-10-06 10:07:01 +01001599 NULL);
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001600 if (err < 0) {
1601 BT_ERR("Failed to create L2CAP proc file");
1602 bt_sock_unregister(BTPROTO_L2CAP);
1603 goto error;
1604 }
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001605
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001606 BT_INFO("L2CAP socket layer initialized");
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001607
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001608 return 0;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001609
1610error:
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001611 proto_unregister(&l2cap_proto);
1612 return err;
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001613}
1614
1615void l2cap_cleanup_sockets(void)
1616{
Masatake YAMATO5b28d952012-07-26 01:29:25 +09001617 bt_procfs_cleanup(&init_net, "l2cap");
David Herrmann5e9d7f82013-02-24 19:36:51 +01001618 bt_sock_unregister(BTPROTO_L2CAP);
Gustavo F. Padovane2174ca2011-02-17 19:16:55 -03001619 proto_unregister(&l2cap_proto);
Gustavo F. Padovanbb58f742011-02-03 20:50:35 -02001620}