?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
SUNRPC: Ensure we always bump the backlog queue in xprt_free_slot
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / net / bluetooth / l2cap_core.c
blobb3bdb482bbe6f5fdf2d197fc1035082f495c448b
1 /*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4 Copyright (C) 2009-2010 Gustavo F. Padovan <gustavo@padovan.org>
5 Copyright (C) 2010 Google Inc.
6
7 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License version 2 as
11 published by the Free Software Foundation;
12
13 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
14 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
16 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
17 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
18 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
19 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
20 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21
22 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
23 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
24 SOFTWARE IS DISCLAIMED.
25 */
26
27 /* Bluetooth L2CAP core. */
28
29 #include <linux/module.h>
30
31 #include <linux/types.h>
32 #include <linux/capability.h>
33 #include <linux/errno.h>
34 #include <linux/kernel.h>
35 #include <linux/sched.h>
36 #include <linux/slab.h>
37 #include <linux/poll.h>
38 #include <linux/fcntl.h>
39 #include <linux/init.h>
40 #include <linux/interrupt.h>
41 #include <linux/socket.h>
42 #include <linux/skbuff.h>
43 #include <linux/list.h>
44 #include <linux/device.h>
45 #include <linux/debugfs.h>
46 #include <linux/seq_file.h>
47 #include <linux/uaccess.h>
48 #include <linux/crc16.h>
49 #include <net/sock.h>
50
51 #include <asm/system.h>
52 #include <asm/unaligned.h>
53
54 #include <net/bluetooth/bluetooth.h>
55 #include <net/bluetooth/hci_core.h>
56 #include <net/bluetooth/l2cap.h>
57 #include <net/bluetooth/smp.h>
58
59 int disable_ertm;
60
61 static u32 l2cap_feat_mask = L2CAP_FEAT_FIXED_CHAN;
62 static u8 l2cap_fixed_chan[8] = { 0x02, };
63
64 static LIST_HEAD(chan_list);
65 static DEFINE_RWLOCK(chan_list_lock);
66
67 static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
68 u8 code, u8 ident, u16 dlen, void *data);
69 static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len,
70 void *data);
71 static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data);
72 static void l2cap_send_disconn_req(struct l2cap_conn *conn,
73 struct l2cap_chan *chan, int err);
74
75 static int l2cap_ertm_data_rcv(struct sock *sk, struct sk_buff *skb);
76
77 /* ---- L2CAP channels ---- */
78
79 static inline void chan_hold(struct l2cap_chan *c)
80 {
81 atomic_inc(&c->refcnt);
82 }
83
84 static inline void chan_put(struct l2cap_chan *c)
85 {
86 if (atomic_dec_and_test(&c->refcnt))
87 kfree(c);
88 }
89
90 static struct l2cap_chan *__l2cap_get_chan_by_dcid(struct l2cap_conn *conn, u16 cid)
91 {
92 struct l2cap_chan *c;
93
94 list_for_each_entry(c, &conn->chan_l, list) {
95 if (c->dcid == cid)
96 return c;
97 }
98 return NULL;
99
100 }
101
102 static struct l2cap_chan *__l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid)
103 {
104 struct l2cap_chan *c;
105
106 list_for_each_entry(c, &conn->chan_l, list) {
107 if (c->scid == cid)
108 return c;
109 }
110 return NULL;
111 }
112
113 /* Find channel with given SCID.
114 * Returns locked socket */
115 static struct l2cap_chan *l2cap_get_chan_by_scid(struct l2cap_conn *conn, u16 cid)
116 {
117 struct l2cap_chan *c;
118
119 read_lock(&conn->chan_lock);
120 c = __l2cap_get_chan_by_scid(conn, cid);
121 if (c)
122 bh_lock_sock(c->sk);
123 read_unlock(&conn->chan_lock);
124 return c;
125 }
126
127 static struct l2cap_chan *__l2cap_get_chan_by_ident(struct l2cap_conn *conn, u8 ident)
128 {
129 struct l2cap_chan *c;
130
131 list_for_each_entry(c, &conn->chan_l, list) {
132 if (c->ident == ident)
133 return c;
134 }
135 return NULL;
136 }
137
138 static inline struct l2cap_chan *l2cap_get_chan_by_ident(struct l2cap_conn *conn, u8 ident)
139 {
140 struct l2cap_chan *c;
141
142 read_lock(&conn->chan_lock);
143 c = __l2cap_get_chan_by_ident(conn, ident);
144 if (c)
145 bh_lock_sock(c->sk);
146 read_unlock(&conn->chan_lock);
147 return c;
148 }
149
150 static struct l2cap_chan *__l2cap_global_chan_by_addr(__le16 psm, bdaddr_t *src)
151 {
152 struct l2cap_chan *c;
153
154 list_for_each_entry(c, &chan_list, global_l) {
155 if (c->sport == psm && !bacmp(&bt_sk(c->sk)->src, src))
156 goto found;
157 }
158
159 c = NULL;
160 found:
161 return c;
162 }
163
164 int l2cap_add_psm(struct l2cap_chan *chan, bdaddr_t *src, __le16 psm)
165 {
166 int err;
167
168 write_lock_bh(&chan_list_lock);
169
170 if (psm && __l2cap_global_chan_by_addr(psm, src)) {
171 err = -EADDRINUSE;
172 goto done;
173 }
174
175 if (psm) {
176 chan->psm = psm;
177 chan->sport = psm;
178 err = 0;
179 } else {
180 u16 p;
181
182 err = -EINVAL;
183 for (p = 0x1001; p < 0x1100; p += 2)
184 if (!__l2cap_global_chan_by_addr(cpu_to_le16(p), src)) {
185 chan->psm = cpu_to_le16(p);
186 chan->sport = cpu_to_le16(p);
187 err = 0;
188 break;
189 }
190 }
191
192 done:
193 write_unlock_bh(&chan_list_lock);
194 return err;
195 }
196
197 int l2cap_add_scid(struct l2cap_chan *chan, __u16 scid)
198 {
199 write_lock_bh(&chan_list_lock);
200
201 chan->scid = scid;
202
203 write_unlock_bh(&chan_list_lock);
204
205 return 0;
206 }
207
208 static u16 l2cap_alloc_cid(struct l2cap_conn *conn)
209 {
210 u16 cid = L2CAP_CID_DYN_START;
211
212 for (; cid < L2CAP_CID_DYN_END; cid++) {
213 if (!__l2cap_get_chan_by_scid(conn, cid))
214 return cid;
215 }
216
217 return 0;
218 }
219
220 static void l2cap_set_timer(struct l2cap_chan *chan, struct timer_list *timer, long timeout)
221 {
222 BT_DBG("chan %p state %d timeout %ld", chan->sk, chan->state, timeout);
223
224 if (!mod_timer(timer, jiffies + msecs_to_jiffies(timeout)))
225 chan_hold(chan);
226 }
227
228 static void l2cap_clear_timer(struct l2cap_chan *chan, struct timer_list *timer)
229 {
230 BT_DBG("chan %p state %d", chan, chan->state);
231
232 if (timer_pending(timer) && del_timer(timer))
233 chan_put(chan);
234 }
235
236 static void l2cap_state_change(struct l2cap_chan *chan, int state)
237 {
238 chan->state = state;
239 chan->ops->state_change(chan->data, state);
240 }
241
242 static void l2cap_chan_timeout(unsigned long arg)
243 {
244 struct l2cap_chan *chan = (struct l2cap_chan *) arg;
245 struct sock *sk = chan->sk;
246 int reason;
247
248 BT_DBG("chan %p state %d", chan, chan->state);
249
250 bh_lock_sock(sk);
251
252 if (sock_owned_by_user(sk)) {
253 /* sk is owned by user. Try again later */
254 __set_chan_timer(chan, HZ / 5);
255 bh_unlock_sock(sk);
256 chan_put(chan);
257 return;
258 }
259
260 if (chan->state == BT_CONNECTED || chan->state == BT_CONFIG)
261 reason = ECONNREFUSED;
262 else if (chan->state == BT_CONNECT &&
263 chan->sec_level != BT_SECURITY_SDP)
264 reason = ECONNREFUSED;
265 else
266 reason = ETIMEDOUT;
267
268 l2cap_chan_close(chan, reason);
269
270 bh_unlock_sock(sk);
271
272 chan->ops->close(chan->data);
273 chan_put(chan);
274 }
275
276 struct l2cap_chan *l2cap_chan_create(struct sock *sk)
277 {
278 struct l2cap_chan *chan;
279
280 chan = kzalloc(sizeof(*chan), GFP_ATOMIC);
281 if (!chan)
282 return NULL;
283
284 chan->sk = sk;
285
286 write_lock_bh(&chan_list_lock);
287 list_add(&chan->global_l, &chan_list);
288 write_unlock_bh(&chan_list_lock);
289
290 setup_timer(&chan->chan_timer, l2cap_chan_timeout, (unsigned long) chan);
291
292 chan->state = BT_OPEN;
293
294 atomic_set(&chan->refcnt, 1);
295
296 return chan;
297 }
298
299 void l2cap_chan_destroy(struct l2cap_chan *chan)
300 {
301 write_lock_bh(&chan_list_lock);
302 list_del(&chan->global_l);
303 write_unlock_bh(&chan_list_lock);
304
305 chan_put(chan);
306 }
307
308 static void __l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan)
309 {
310 BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn,
311 chan->psm, chan->dcid);
312
313 conn->disc_reason = 0x13;
314
315 chan->conn = conn;
316
317 if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED) {
318 if (conn->hcon->type == LE_LINK) {
319 /* LE connection */
320 chan->omtu = L2CAP_LE_DEFAULT_MTU;
321 chan->scid = L2CAP_CID_LE_DATA;
322 chan->dcid = L2CAP_CID_LE_DATA;
323 } else {
324 /* Alloc CID for connection-oriented socket */
325 chan->scid = l2cap_alloc_cid(conn);
326 chan->omtu = L2CAP_DEFAULT_MTU;
327 }
328 } else if (chan->chan_type == L2CAP_CHAN_CONN_LESS) {
329 /* Connectionless socket */
330 chan->scid = L2CAP_CID_CONN_LESS;
331 chan->dcid = L2CAP_CID_CONN_LESS;
332 chan->omtu = L2CAP_DEFAULT_MTU;
333 } else {
334 /* Raw socket can send/recv signalling messages only */
335 chan->scid = L2CAP_CID_SIGNALING;
336 chan->dcid = L2CAP_CID_SIGNALING;
337 chan->omtu = L2CAP_DEFAULT_MTU;
338 }
339
340 chan_hold(chan);
341
342 list_add(&chan->list, &conn->chan_l);
343 }
344
345 /* Delete channel.
346 * Must be called on the locked socket. */
347 static void l2cap_chan_del(struct l2cap_chan *chan, int err)
348 {
349 struct sock *sk = chan->sk;
350 struct l2cap_conn *conn = chan->conn;
351 struct sock *parent = bt_sk(sk)->parent;
352
353 __clear_chan_timer(chan);
354
355 BT_DBG("chan %p, conn %p, err %d", chan, conn, err);
356
357 if (conn) {
358 /* Delete from channel list */
359 write_lock_bh(&conn->chan_lock);
360 list_del(&chan->list);
361 write_unlock_bh(&conn->chan_lock);
362 chan_put(chan);
363
364 chan->conn = NULL;
365 hci_conn_put(conn->hcon);
366 }
367
368 l2cap_state_change(chan, BT_CLOSED);
369 sock_set_flag(sk, SOCK_ZAPPED);
370
371 if (err)
372 sk->sk_err = err;
373
374 if (parent) {
375 bt_accept_unlink(sk);
376 parent->sk_data_ready(parent, 0);
377 } else
378 sk->sk_state_change(sk);
379
380 if (!(test_bit(CONF_OUTPUT_DONE, &chan->conf_state) &&
381 test_bit(CONF_INPUT_DONE, &chan->conf_state)))
382 return;
383
384 skb_queue_purge(&chan->tx_q);
385
386 if (chan->mode == L2CAP_MODE_ERTM) {
387 struct srej_list *l, *tmp;
388
389 __clear_retrans_timer(chan);
390 __clear_monitor_timer(chan);
391 __clear_ack_timer(chan);
392
393 skb_queue_purge(&chan->srej_q);
394
395 list_for_each_entry_safe(l, tmp, &chan->srej_l, list) {
396 list_del(&l->list);
397 kfree(l);
398 }
399 }
400 }
401
402 static void l2cap_chan_cleanup_listen(struct sock *parent)
403 {
404 struct sock *sk;
405
406 BT_DBG("parent %p", parent);
407
408 /* Close not yet accepted channels */
409 while ((sk = bt_accept_dequeue(parent, NULL))) {
410 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
411 __clear_chan_timer(chan);
412 lock_sock(sk);
413 l2cap_chan_close(chan, ECONNRESET);
414 release_sock(sk);
415 chan->ops->close(chan->data);
416 }
417 }
418
419 void l2cap_chan_close(struct l2cap_chan *chan, int reason)
420 {
421 struct l2cap_conn *conn = chan->conn;
422 struct sock *sk = chan->sk;
423
424 BT_DBG("chan %p state %d socket %p", chan, chan->state, sk->sk_socket);
425
426 switch (chan->state) {
427 case BT_LISTEN:
428 l2cap_chan_cleanup_listen(sk);
429
430 l2cap_state_change(chan, BT_CLOSED);
431 sock_set_flag(sk, SOCK_ZAPPED);
432 break;
433
434 case BT_CONNECTED:
435 case BT_CONFIG:
436 if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED &&
437 conn->hcon->type == ACL_LINK) {
438 __clear_chan_timer(chan);
439 __set_chan_timer(chan, sk->sk_sndtimeo);
440 l2cap_send_disconn_req(conn, chan, reason);
441 } else
442 l2cap_chan_del(chan, reason);
443 break;
444
445 case BT_CONNECT2:
446 if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED &&
447 conn->hcon->type == ACL_LINK) {
448 struct l2cap_conn_rsp rsp;
449 __u16 result;
450
451 if (bt_sk(sk)->defer_setup)
452 result = L2CAP_CR_SEC_BLOCK;
453 else
454 result = L2CAP_CR_BAD_PSM;
455 l2cap_state_change(chan, BT_DISCONN);
456
457 rsp.scid = cpu_to_le16(chan->dcid);
458 rsp.dcid = cpu_to_le16(chan->scid);
459 rsp.result = cpu_to_le16(result);
460 rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
461 l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
462 sizeof(rsp), &rsp);
463 }
464
465 l2cap_chan_del(chan, reason);
466 break;
467
468 case BT_CONNECT:
469 case BT_DISCONN:
470 l2cap_chan_del(chan, reason);
471 break;
472
473 default:
474 sock_set_flag(sk, SOCK_ZAPPED);
475 break;
476 }
477 }
478
479 static inline u8 l2cap_get_auth_type(struct l2cap_chan *chan)
480 {
481 if (chan->chan_type == L2CAP_CHAN_RAW) {
482 switch (chan->sec_level) {
483 case BT_SECURITY_HIGH:
484 return HCI_AT_DEDICATED_BONDING_MITM;
485 case BT_SECURITY_MEDIUM:
486 return HCI_AT_DEDICATED_BONDING;
487 default:
488 return HCI_AT_NO_BONDING;
489 }
490 } else if (chan->psm == cpu_to_le16(0x0001)) {
491 if (chan->sec_level == BT_SECURITY_LOW)
492 chan->sec_level = BT_SECURITY_SDP;
493
494 if (chan->sec_level == BT_SECURITY_HIGH)
495 return HCI_AT_NO_BONDING_MITM;
496 else
497 return HCI_AT_NO_BONDING;
498 } else {
499 switch (chan->sec_level) {
500 case BT_SECURITY_HIGH:
501 return HCI_AT_GENERAL_BONDING_MITM;
502 case BT_SECURITY_MEDIUM:
503 return HCI_AT_GENERAL_BONDING;
504 default:
505 return HCI_AT_NO_BONDING;
506 }
507 }
508 }
509
510 /* Service level security */
511 static inline int l2cap_check_security(struct l2cap_chan *chan)
512 {
513 struct l2cap_conn *conn = chan->conn;
514 __u8 auth_type;
515
516 auth_type = l2cap_get_auth_type(chan);
517
518 return hci_conn_security(conn->hcon, chan->sec_level, auth_type);
519 }
520
521 static u8 l2cap_get_ident(struct l2cap_conn *conn)
522 {
523 u8 id;
524
525 /* Get next available identificator.
526 * 1 - 128 are used by kernel.
527 * 129 - 199 are reserved.
528 * 200 - 254 are used by utilities like l2ping, etc.
529 */
530
531 spin_lock_bh(&conn->lock);
532
533 if (++conn->tx_ident > 128)
534 conn->tx_ident = 1;
535
536 id = conn->tx_ident;
537
538 spin_unlock_bh(&conn->lock);
539
540 return id;
541 }
542
543 static void l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data)
544 {
545 struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data);
546 u8 flags;
547
548 BT_DBG("code 0x%2.2x", code);
549
550 if (!skb)
551 return;
552
553 if (lmp_no_flush_capable(conn->hcon->hdev))
554 flags = ACL_START_NO_FLUSH;
555 else
556 flags = ACL_START;
557
558 bt_cb(skb)->force_active = BT_POWER_FORCE_ACTIVE_ON;
559
560 hci_send_acl(conn->hcon, skb, flags);
561 }
562
563 static inline void l2cap_send_sframe(struct l2cap_chan *chan, u16 control)
564 {
565 struct sk_buff *skb;
566 struct l2cap_hdr *lh;
567 struct l2cap_conn *conn = chan->conn;
568 int count, hlen = L2CAP_HDR_SIZE + 2;
569 u8 flags;
570
571 if (chan->state != BT_CONNECTED)
572 return;
573
574 if (chan->fcs == L2CAP_FCS_CRC16)
575 hlen += 2;
576
577 BT_DBG("chan %p, control 0x%2.2x", chan, control);
578
579 count = min_t(unsigned int, conn->mtu, hlen);
580 control |= L2CAP_CTRL_FRAME_TYPE;
581
582 if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))
583 control |= L2CAP_CTRL_FINAL;
584
585 if (test_and_clear_bit(CONN_SEND_PBIT, &chan->conn_state))
586 control |= L2CAP_CTRL_POLL;
587
588 skb = bt_skb_alloc(count, GFP_ATOMIC);
589 if (!skb)
590 return;
591
592 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
593 lh->len = cpu_to_le16(hlen - L2CAP_HDR_SIZE);
594 lh->cid = cpu_to_le16(chan->dcid);
595 put_unaligned_le16(control, skb_put(skb, 2));
596
597 if (chan->fcs == L2CAP_FCS_CRC16) {
598 u16 fcs = crc16(0, (u8 *)lh, count - 2);
599 put_unaligned_le16(fcs, skb_put(skb, 2));
600 }
601
602 if (lmp_no_flush_capable(conn->hcon->hdev))
603 flags = ACL_START_NO_FLUSH;
604 else
605 flags = ACL_START;
606
607 bt_cb(skb)->force_active = chan->force_active;
608
609 hci_send_acl(chan->conn->hcon, skb, flags);
610 }
611
612 static inline void l2cap_send_rr_or_rnr(struct l2cap_chan *chan, u16 control)
613 {
614 if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
615 control |= L2CAP_SUPER_RCV_NOT_READY;
616 set_bit(CONN_RNR_SENT, &chan->conn_state);
617 } else
618 control |= L2CAP_SUPER_RCV_READY;
619
620 control |= chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
621
622 l2cap_send_sframe(chan, control);
623 }
624
625 static inline int __l2cap_no_conn_pending(struct l2cap_chan *chan)
626 {
627 return !test_bit(CONF_CONNECT_PEND, &chan->conf_state);
628 }
629
630 static void l2cap_do_start(struct l2cap_chan *chan)
631 {
632 struct l2cap_conn *conn = chan->conn;
633
634 if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) {
635 if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE))
636 return;
637
638 if (l2cap_check_security(chan) &&
639 __l2cap_no_conn_pending(chan)) {
640 struct l2cap_conn_req req;
641 req.scid = cpu_to_le16(chan->scid);
642 req.psm = chan->psm;
643
644 chan->ident = l2cap_get_ident(conn);
645 set_bit(CONF_CONNECT_PEND, &chan->conf_state);
646
647 l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ,
648 sizeof(req), &req);
649 }
650 } else {
651 struct l2cap_info_req req;
652 req.type = cpu_to_le16(L2CAP_IT_FEAT_MASK);
653
654 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT;
655 conn->info_ident = l2cap_get_ident(conn);
656
657 mod_timer(&conn->info_timer, jiffies +
658 msecs_to_jiffies(L2CAP_INFO_TIMEOUT));
659
660 l2cap_send_cmd(conn, conn->info_ident,
661 L2CAP_INFO_REQ, sizeof(req), &req);
662 }
663 }
664
665 static inline int l2cap_mode_supported(__u8 mode, __u32 feat_mask)
666 {
667 u32 local_feat_mask = l2cap_feat_mask;
668 if (!disable_ertm)
669 local_feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING;
670
671 switch (mode) {
672 case L2CAP_MODE_ERTM:
673 return L2CAP_FEAT_ERTM & feat_mask & local_feat_mask;
674 case L2CAP_MODE_STREAMING:
675 return L2CAP_FEAT_STREAMING & feat_mask & local_feat_mask;
676 default:
677 return 0x00;
678 }
679 }
680
681 static void l2cap_send_disconn_req(struct l2cap_conn *conn, struct l2cap_chan *chan, int err)
682 {
683 struct sock *sk;
684 struct l2cap_disconn_req req;
685
686 if (!conn)
687 return;
688
689 sk = chan->sk;
690
691 if (chan->mode == L2CAP_MODE_ERTM) {
692 __clear_retrans_timer(chan);
693 __clear_monitor_timer(chan);
694 __clear_ack_timer(chan);
695 }
696
697 req.dcid = cpu_to_le16(chan->dcid);
698 req.scid = cpu_to_le16(chan->scid);
699 l2cap_send_cmd(conn, l2cap_get_ident(conn),
700 L2CAP_DISCONN_REQ, sizeof(req), &req);
701
702 l2cap_state_change(chan, BT_DISCONN);
703 sk->sk_err = err;
704 }
705
706 /* ---- L2CAP connections ---- */
707 static void l2cap_conn_start(struct l2cap_conn *conn)
708 {
709 struct l2cap_chan *chan, *tmp;
710
711 BT_DBG("conn %p", conn);
712
713 read_lock(&conn->chan_lock);
714
715 list_for_each_entry_safe(chan, tmp, &conn->chan_l, list) {
716 struct sock *sk = chan->sk;
717
718 bh_lock_sock(sk);
719
720 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
721 bh_unlock_sock(sk);
722 continue;
723 }
724
725 if (chan->state == BT_CONNECT) {
726 struct l2cap_conn_req req;
727
728 if (!l2cap_check_security(chan) ||
729 !__l2cap_no_conn_pending(chan)) {
730 bh_unlock_sock(sk);
731 continue;
732 }
733
734 if (!l2cap_mode_supported(chan->mode, conn->feat_mask)
735 && test_bit(CONF_STATE2_DEVICE,
736 &chan->conf_state)) {
737 /* l2cap_chan_close() calls list_del(chan)
738 * so release the lock */
739 read_unlock(&conn->chan_lock);
740 l2cap_chan_close(chan, ECONNRESET);
741 read_lock(&conn->chan_lock);
742 bh_unlock_sock(sk);
743 continue;
744 }
745
746 req.scid = cpu_to_le16(chan->scid);
747 req.psm = chan->psm;
748
749 chan->ident = l2cap_get_ident(conn);
750 set_bit(CONF_CONNECT_PEND, &chan->conf_state);
751
752 l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_REQ,
753 sizeof(req), &req);
754
755 } else if (chan->state == BT_CONNECT2) {
756 struct l2cap_conn_rsp rsp;
757 char buf[128];
758 rsp.scid = cpu_to_le16(chan->dcid);
759 rsp.dcid = cpu_to_le16(chan->scid);
760
761 if (l2cap_check_security(chan)) {
762 if (bt_sk(sk)->defer_setup) {
763 struct sock *parent = bt_sk(sk)->parent;
764 rsp.result = cpu_to_le16(L2CAP_CR_PEND);
765 rsp.status = cpu_to_le16(L2CAP_CS_AUTHOR_PEND);
766 if (parent)
767 parent->sk_data_ready(parent, 0);
768
769 } else {
770 l2cap_state_change(chan, BT_CONFIG);
771 rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
772 rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
773 }
774 } else {
775 rsp.result = cpu_to_le16(L2CAP_CR_PEND);
776 rsp.status = cpu_to_le16(L2CAP_CS_AUTHEN_PEND);
777 }
778
779 l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
780 sizeof(rsp), &rsp);
781
782 if (test_bit(CONF_REQ_SENT, &chan->conf_state) ||
783 rsp.result != L2CAP_CR_SUCCESS) {
784 bh_unlock_sock(sk);
785 continue;
786 }
787
788 set_bit(CONF_REQ_SENT, &chan->conf_state);
789 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
790 l2cap_build_conf_req(chan, buf), buf);
791 chan->num_conf_req++;
792 }
793
794 bh_unlock_sock(sk);
795 }
796
797 read_unlock(&conn->chan_lock);
798 }
799
800 /* Find socket with cid and source bdaddr.
801 * Returns closest match, locked.
802 */
803 static struct l2cap_chan *l2cap_global_chan_by_scid(int state, __le16 cid, bdaddr_t *src)
804 {
805 struct l2cap_chan *c, *c1 = NULL;
806
807 read_lock(&chan_list_lock);
808
809 list_for_each_entry(c, &chan_list, global_l) {
810 struct sock *sk = c->sk;
811
812 if (state && c->state != state)
813 continue;
814
815 if (c->scid == cid) {
816 /* Exact match. */
817 if (!bacmp(&bt_sk(sk)->src, src)) {
818 read_unlock(&chan_list_lock);
819 return c;
820 }
821
822 /* Closest match */
823 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
824 c1 = c;
825 }
826 }
827
828 read_unlock(&chan_list_lock);
829
830 return c1;
831 }
832
833 static void l2cap_le_conn_ready(struct l2cap_conn *conn)
834 {
835 struct sock *parent, *sk;
836 struct l2cap_chan *chan, *pchan;
837
838 BT_DBG("");
839
840 /* Check if we have socket listening on cid */
841 pchan = l2cap_global_chan_by_scid(BT_LISTEN, L2CAP_CID_LE_DATA,
842 conn->src);
843 if (!pchan)
844 return;
845
846 parent = pchan->sk;
847
848 bh_lock_sock(parent);
849
850 /* Check for backlog size */
851 if (sk_acceptq_is_full(parent)) {
852 BT_DBG("backlog full %d", parent->sk_ack_backlog);
853 goto clean;
854 }
855
856 chan = pchan->ops->new_connection(pchan->data);
857 if (!chan)
858 goto clean;
859
860 sk = chan->sk;
861
862 write_lock_bh(&conn->chan_lock);
863
864 hci_conn_hold(conn->hcon);
865
866 bacpy(&bt_sk(sk)->src, conn->src);
867 bacpy(&bt_sk(sk)->dst, conn->dst);
868
869 bt_accept_enqueue(parent, sk);
870
871 __l2cap_chan_add(conn, chan);
872
873 __set_chan_timer(chan, sk->sk_sndtimeo);
874
875 l2cap_state_change(chan, BT_CONNECTED);
876 parent->sk_data_ready(parent, 0);
877
878 write_unlock_bh(&conn->chan_lock);
879
880 clean:
881 bh_unlock_sock(parent);
882 }
883
884 static void l2cap_chan_ready(struct sock *sk)
885 {
886 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
887 struct sock *parent = bt_sk(sk)->parent;
888
889 BT_DBG("sk %p, parent %p", sk, parent);
890
891 chan->conf_state = 0;
892 __clear_chan_timer(chan);
893
894 l2cap_state_change(chan, BT_CONNECTED);
895 sk->sk_state_change(sk);
896
897 if (parent)
898 parent->sk_data_ready(parent, 0);
899 }
900
901 static void l2cap_conn_ready(struct l2cap_conn *conn)
902 {
903 struct l2cap_chan *chan;
904
905 BT_DBG("conn %p", conn);
906
907 if (!conn->hcon->out && conn->hcon->type == LE_LINK)
908 l2cap_le_conn_ready(conn);
909
910 read_lock(&conn->chan_lock);
911
912 list_for_each_entry(chan, &conn->chan_l, list) {
913 struct sock *sk = chan->sk;
914
915 bh_lock_sock(sk);
916
917 if (conn->hcon->type == LE_LINK) {
918 if (smp_conn_security(conn, chan->sec_level))
919 l2cap_chan_ready(sk);
920
921 } else if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
922 __clear_chan_timer(chan);
923 l2cap_state_change(chan, BT_CONNECTED);
924 sk->sk_state_change(sk);
925
926 } else if (chan->state == BT_CONNECT)
927 l2cap_do_start(chan);
928
929 bh_unlock_sock(sk);
930 }
931
932 read_unlock(&conn->chan_lock);
933 }
934
935 /* Notify sockets that we cannot guaranty reliability anymore */
936 static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err)
937 {
938 struct l2cap_chan *chan;
939
940 BT_DBG("conn %p", conn);
941
942 read_lock(&conn->chan_lock);
943
944 list_for_each_entry(chan, &conn->chan_l, list) {
945 struct sock *sk = chan->sk;
946
947 if (chan->force_reliable)
948 sk->sk_err = err;
949 }
950
951 read_unlock(&conn->chan_lock);
952 }
953
954 static void l2cap_info_timeout(unsigned long arg)
955 {
956 struct l2cap_conn *conn = (void *) arg;
957
958 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
959 conn->info_ident = 0;
960
961 l2cap_conn_start(conn);
962 }
963
964 static void l2cap_conn_del(struct hci_conn *hcon, int err)
965 {
966 struct l2cap_conn *conn = hcon->l2cap_data;
967 struct l2cap_chan *chan, *l;
968 struct sock *sk;
969
970 if (!conn)
971 return;
972
973 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
974
975 kfree_skb(conn->rx_skb);
976
977 /* Kill channels */
978 list_for_each_entry_safe(chan, l, &conn->chan_l, list) {
979 sk = chan->sk;
980 bh_lock_sock(sk);
981 l2cap_chan_del(chan, err);
982 bh_unlock_sock(sk);
983 chan->ops->close(chan->data);
984 }
985
986 if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT)
987 del_timer_sync(&conn->info_timer);
988
989 if (test_bit(HCI_CONN_ENCRYPT_PEND, &hcon->pend))
990 del_timer(&conn->security_timer);
991
992 hcon->l2cap_data = NULL;
993 kfree(conn);
994 }
995
996 static void security_timeout(unsigned long arg)
997 {
998 struct l2cap_conn *conn = (void *) arg;
999
1000 l2cap_conn_del(conn->hcon, ETIMEDOUT);
1001 }
1002
1003 static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status)
1004 {
1005 struct l2cap_conn *conn = hcon->l2cap_data;
1006
1007 if (conn || status)
1008 return conn;
1009
1010 conn = kzalloc(sizeof(struct l2cap_conn), GFP_ATOMIC);
1011 if (!conn)
1012 return NULL;
1013
1014 hcon->l2cap_data = conn;
1015 conn->hcon = hcon;
1016
1017 BT_DBG("hcon %p conn %p", hcon, conn);
1018
1019 if (hcon->hdev->le_mtu && hcon->type == LE_LINK)
1020 conn->mtu = hcon->hdev->le_mtu;
1021 else
1022 conn->mtu = hcon->hdev->acl_mtu;
1023
1024 conn->src = &hcon->hdev->bdaddr;
1025 conn->dst = &hcon->dst;
1026
1027 conn->feat_mask = 0;
1028
1029 spin_lock_init(&conn->lock);
1030 rwlock_init(&conn->chan_lock);
1031
1032 INIT_LIST_HEAD(&conn->chan_l);
1033
1034 if (hcon->type == LE_LINK)
1035 setup_timer(&conn->security_timer, security_timeout,
1036 (unsigned long) conn);
1037 else
1038 setup_timer(&conn->info_timer, l2cap_info_timeout,
1039 (unsigned long) conn);
1040
1041 conn->disc_reason = 0x13;
1042
1043 return conn;
1044 }
1045
1046 static inline void l2cap_chan_add(struct l2cap_conn *conn, struct l2cap_chan *chan)
1047 {
1048 write_lock_bh(&conn->chan_lock);
1049 __l2cap_chan_add(conn, chan);
1050 write_unlock_bh(&conn->chan_lock);
1051 }
1052
1053 /* ---- Socket interface ---- */
1054
1055 /* Find socket with psm and source bdaddr.
1056 * Returns closest match.
1057 */
1058 static struct l2cap_chan *l2cap_global_chan_by_psm(int state, __le16 psm, bdaddr_t *src)
1059 {
1060 struct l2cap_chan *c, *c1 = NULL;
1061
1062 read_lock(&chan_list_lock);
1063
1064 list_for_each_entry(c, &chan_list, global_l) {
1065 struct sock *sk = c->sk;
1066
1067 if (state && c->state != state)
1068 continue;
1069
1070 if (c->psm == psm) {
1071 /* Exact match. */
1072 if (!bacmp(&bt_sk(sk)->src, src)) {
1073 read_unlock(&chan_list_lock);
1074 return c;
1075 }
1076
1077 /* Closest match */
1078 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
1079 c1 = c;
1080 }
1081 }
1082
1083 read_unlock(&chan_list_lock);
1084
1085 return c1;
1086 }
1087
1088 int l2cap_chan_connect(struct l2cap_chan *chan)
1089 {
1090 struct sock *sk = chan->sk;
1091 bdaddr_t *src = &bt_sk(sk)->src;
1092 bdaddr_t *dst = &bt_sk(sk)->dst;
1093 struct l2cap_conn *conn;
1094 struct hci_conn *hcon;
1095 struct hci_dev *hdev;
1096 __u8 auth_type;
1097 int err;
1098
1099 BT_DBG("%s -> %s psm 0x%2.2x", batostr(src), batostr(dst),
1100 chan->psm);
1101
1102 hdev = hci_get_route(dst, src);
1103 if (!hdev)
1104 return -EHOSTUNREACH;
1105
1106 hci_dev_lock_bh(hdev);
1107
1108 auth_type = l2cap_get_auth_type(chan);
1109
1110 if (chan->dcid == L2CAP_CID_LE_DATA)
1111 hcon = hci_connect(hdev, LE_LINK, dst,
1112 chan->sec_level, auth_type);
1113 else
1114 hcon = hci_connect(hdev, ACL_LINK, dst,
1115 chan->sec_level, auth_type);
1116
1117 if (IS_ERR(hcon)) {
1118 err = PTR_ERR(hcon);
1119 goto done;
1120 }
1121
1122 conn = l2cap_conn_add(hcon, 0);
1123 if (!conn) {
1124 hci_conn_put(hcon);
1125 err = -ENOMEM;
1126 goto done;
1127 }
1128
1129 /* Update source addr of the socket */
1130 bacpy(src, conn->src);
1131
1132 l2cap_chan_add(conn, chan);
1133
1134 l2cap_state_change(chan, BT_CONNECT);
1135 __set_chan_timer(chan, sk->sk_sndtimeo);
1136
1137 if (hcon->state == BT_CONNECTED) {
1138 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED) {
1139 __clear_chan_timer(chan);
1140 if (l2cap_check_security(chan))
1141 l2cap_state_change(chan, BT_CONNECTED);
1142 } else
1143 l2cap_do_start(chan);
1144 }
1145
1146 err = 0;
1147
1148 done:
1149 hci_dev_unlock_bh(hdev);
1150 hci_dev_put(hdev);
1151 return err;
1152 }
1153
1154 int __l2cap_wait_ack(struct sock *sk)
1155 {
1156 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1157 DECLARE_WAITQUEUE(wait, current);
1158 int err = 0;
1159 int timeo = HZ/5;
1160
1161 add_wait_queue(sk_sleep(sk), &wait);
1162 set_current_state(TASK_INTERRUPTIBLE);
1163 while (chan->unacked_frames > 0 && chan->conn) {
1164 if (!timeo)
1165 timeo = HZ/5;
1166
1167 if (signal_pending(current)) {
1168 err = sock_intr_errno(timeo);
1169 break;
1170 }
1171
1172 release_sock(sk);
1173 timeo = schedule_timeout(timeo);
1174 lock_sock(sk);
1175 set_current_state(TASK_INTERRUPTIBLE);
1176
1177 err = sock_error(sk);
1178 if (err)
1179 break;
1180 }
1181 set_current_state(TASK_RUNNING);
1182 remove_wait_queue(sk_sleep(sk), &wait);
1183 return err;
1184 }
1185
1186 static void l2cap_monitor_timeout(unsigned long arg)
1187 {
1188 struct l2cap_chan *chan = (void *) arg;
1189 struct sock *sk = chan->sk;
1190
1191 BT_DBG("chan %p", chan);
1192
1193 bh_lock_sock(sk);
1194 if (chan->retry_count >= chan->remote_max_tx) {
1195 l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED);
1196 bh_unlock_sock(sk);
1197 return;
1198 }
1199
1200 chan->retry_count++;
1201 __set_monitor_timer(chan);
1202
1203 l2cap_send_rr_or_rnr(chan, L2CAP_CTRL_POLL);
1204 bh_unlock_sock(sk);
1205 }
1206
1207 static void l2cap_retrans_timeout(unsigned long arg)
1208 {
1209 struct l2cap_chan *chan = (void *) arg;
1210 struct sock *sk = chan->sk;
1211
1212 BT_DBG("chan %p", chan);
1213
1214 bh_lock_sock(sk);
1215 chan->retry_count = 1;
1216 __set_monitor_timer(chan);
1217
1218 set_bit(CONN_WAIT_F, &chan->conn_state);
1219
1220 l2cap_send_rr_or_rnr(chan, L2CAP_CTRL_POLL);
1221 bh_unlock_sock(sk);
1222 }
1223
1224 static void l2cap_drop_acked_frames(struct l2cap_chan *chan)
1225 {
1226 struct sk_buff *skb;
1227
1228 while ((skb = skb_peek(&chan->tx_q)) &&
1229 chan->unacked_frames) {
1230 if (bt_cb(skb)->tx_seq == chan->expected_ack_seq)
1231 break;
1232
1233 skb = skb_dequeue(&chan->tx_q);
1234 kfree_skb(skb);
1235
1236 chan->unacked_frames--;
1237 }
1238
1239 if (!chan->unacked_frames)
1240 __clear_retrans_timer(chan);
1241 }
1242
1243 void l2cap_do_send(struct l2cap_chan *chan, struct sk_buff *skb)
1244 {
1245 struct hci_conn *hcon = chan->conn->hcon;
1246 u16 flags;
1247
1248 BT_DBG("chan %p, skb %p len %d", chan, skb, skb->len);
1249
1250 if (!chan->flushable && lmp_no_flush_capable(hcon->hdev))
1251 flags = ACL_START_NO_FLUSH;
1252 else
1253 flags = ACL_START;
1254
1255 bt_cb(skb)->force_active = chan->force_active;
1256 hci_send_acl(hcon, skb, flags);
1257 }
1258
1259 void l2cap_streaming_send(struct l2cap_chan *chan)
1260 {
1261 struct sk_buff *skb;
1262 u16 control, fcs;
1263
1264 while ((skb = skb_dequeue(&chan->tx_q))) {
1265 control = get_unaligned_le16(skb->data + L2CAP_HDR_SIZE);
1266 control |= chan->next_tx_seq << L2CAP_CTRL_TXSEQ_SHIFT;
1267 put_unaligned_le16(control, skb->data + L2CAP_HDR_SIZE);
1268
1269 if (chan->fcs == L2CAP_FCS_CRC16) {
1270 fcs = crc16(0, (u8 *)skb->data, skb->len - 2);
1271 put_unaligned_le16(fcs, skb->data + skb->len - 2);
1272 }
1273
1274 l2cap_do_send(chan, skb);
1275
1276 chan->next_tx_seq = (chan->next_tx_seq + 1) % 64;
1277 }
1278 }
1279
1280 static void l2cap_retransmit_one_frame(struct l2cap_chan *chan, u8 tx_seq)
1281 {
1282 struct sk_buff *skb, *tx_skb;
1283 u16 control, fcs;
1284
1285 skb = skb_peek(&chan->tx_q);
1286 if (!skb)
1287 return;
1288
1289 do {
1290 if (bt_cb(skb)->tx_seq == tx_seq)
1291 break;
1292
1293 if (skb_queue_is_last(&chan->tx_q, skb))
1294 return;
1295
1296 } while ((skb = skb_queue_next(&chan->tx_q, skb)));
1297
1298 if (chan->remote_max_tx &&
1299 bt_cb(skb)->retries == chan->remote_max_tx) {
1300 l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED);
1301 return;
1302 }
1303
1304 tx_skb = skb_clone(skb, GFP_ATOMIC);
1305 bt_cb(skb)->retries++;
1306 control = get_unaligned_le16(tx_skb->data + L2CAP_HDR_SIZE);
1307 control &= L2CAP_CTRL_SAR;
1308
1309 if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))
1310 control |= L2CAP_CTRL_FINAL;
1311
1312 control |= (chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT)
1313 | (tx_seq << L2CAP_CTRL_TXSEQ_SHIFT);
1314
1315 put_unaligned_le16(control, tx_skb->data + L2CAP_HDR_SIZE);
1316
1317 if (chan->fcs == L2CAP_FCS_CRC16) {
1318 fcs = crc16(0, (u8 *)tx_skb->data, tx_skb->len - 2);
1319 put_unaligned_le16(fcs, tx_skb->data + tx_skb->len - 2);
1320 }
1321
1322 l2cap_do_send(chan, tx_skb);
1323 }
1324
1325 int l2cap_ertm_send(struct l2cap_chan *chan)
1326 {
1327 struct sk_buff *skb, *tx_skb;
1328 u16 control, fcs;
1329 int nsent = 0;
1330
1331 if (chan->state != BT_CONNECTED)
1332 return -ENOTCONN;
1333
1334 while ((skb = chan->tx_send_head) && (!l2cap_tx_window_full(chan))) {
1335
1336 if (chan->remote_max_tx &&
1337 bt_cb(skb)->retries == chan->remote_max_tx) {
1338 l2cap_send_disconn_req(chan->conn, chan, ECONNABORTED);
1339 break;
1340 }
1341
1342 tx_skb = skb_clone(skb, GFP_ATOMIC);
1343
1344 bt_cb(skb)->retries++;
1345
1346 control = get_unaligned_le16(tx_skb->data + L2CAP_HDR_SIZE);
1347 control &= L2CAP_CTRL_SAR;
1348
1349 if (test_and_clear_bit(CONN_SEND_FBIT, &chan->conn_state))
1350 control |= L2CAP_CTRL_FINAL;
1351
1352 control |= (chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT)
1353 | (chan->next_tx_seq << L2CAP_CTRL_TXSEQ_SHIFT);
1354 put_unaligned_le16(control, tx_skb->data + L2CAP_HDR_SIZE);
1355
1356
1357 if (chan->fcs == L2CAP_FCS_CRC16) {
1358 fcs = crc16(0, (u8 *)skb->data, tx_skb->len - 2);
1359 put_unaligned_le16(fcs, skb->data + tx_skb->len - 2);
1360 }
1361
1362 l2cap_do_send(chan, tx_skb);
1363
1364 __set_retrans_timer(chan);
1365
1366 bt_cb(skb)->tx_seq = chan->next_tx_seq;
1367 chan->next_tx_seq = (chan->next_tx_seq + 1) % 64;
1368
1369 if (bt_cb(skb)->retries == 1)
1370 chan->unacked_frames++;
1371
1372 chan->frames_sent++;
1373
1374 if (skb_queue_is_last(&chan->tx_q, skb))
1375 chan->tx_send_head = NULL;
1376 else
1377 chan->tx_send_head = skb_queue_next(&chan->tx_q, skb);
1378
1379 nsent++;
1380 }
1381
1382 return nsent;
1383 }
1384
1385 static int l2cap_retransmit_frames(struct l2cap_chan *chan)
1386 {
1387 int ret;
1388
1389 if (!skb_queue_empty(&chan->tx_q))
1390 chan->tx_send_head = chan->tx_q.next;
1391
1392 chan->next_tx_seq = chan->expected_ack_seq;
1393 ret = l2cap_ertm_send(chan);
1394 return ret;
1395 }
1396
1397 static void l2cap_send_ack(struct l2cap_chan *chan)
1398 {
1399 u16 control = 0;
1400
1401 control |= chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
1402
1403 if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
1404 control |= L2CAP_SUPER_RCV_NOT_READY;
1405 set_bit(CONN_RNR_SENT, &chan->conn_state);
1406 l2cap_send_sframe(chan, control);
1407 return;
1408 }
1409
1410 if (l2cap_ertm_send(chan) > 0)
1411 return;
1412
1413 control |= L2CAP_SUPER_RCV_READY;
1414 l2cap_send_sframe(chan, control);
1415 }
1416
1417 static void l2cap_send_srejtail(struct l2cap_chan *chan)
1418 {
1419 struct srej_list *tail;
1420 u16 control;
1421
1422 control = L2CAP_SUPER_SELECT_REJECT;
1423 control |= L2CAP_CTRL_FINAL;
1424
1425 tail = list_entry((&chan->srej_l)->prev, struct srej_list, list);
1426 control |= tail->tx_seq << L2CAP_CTRL_REQSEQ_SHIFT;
1427
1428 l2cap_send_sframe(chan, control);
1429 }
1430
1431 static inline int l2cap_skbuff_fromiovec(struct sock *sk, struct msghdr *msg, int len, int count, struct sk_buff *skb)
1432 {
1433 struct l2cap_conn *conn = l2cap_pi(sk)->chan->conn;
1434 struct sk_buff **frag;
1435 int err, sent = 0;
1436
1437 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count))
1438 return -EFAULT;
1439
1440 sent += count;
1441 len -= count;
1442
1443 /* Continuation fragments (no L2CAP header) */
1444 frag = &skb_shinfo(skb)->frag_list;
1445 while (len) {
1446 count = min_t(unsigned int, conn->mtu, len);
1447
1448 *frag = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err);
1449 if (!*frag)
1450 return err;
1451 if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count))
1452 return -EFAULT;
1453
1454 sent += count;
1455 len -= count;
1456
1457 frag = &(*frag)->next;
1458 }
1459
1460 return sent;
1461 }
1462
1463 struct sk_buff *l2cap_create_connless_pdu(struct l2cap_chan *chan, struct msghdr *msg, size_t len)
1464 {
1465 struct sock *sk = chan->sk;
1466 struct l2cap_conn *conn = chan->conn;
1467 struct sk_buff *skb;
1468 int err, count, hlen = L2CAP_HDR_SIZE + 2;
1469 struct l2cap_hdr *lh;
1470
1471 BT_DBG("sk %p len %d", sk, (int)len);
1472
1473 count = min_t(unsigned int, (conn->mtu - hlen), len);
1474 skb = bt_skb_send_alloc(sk, count + hlen,
1475 msg->msg_flags & MSG_DONTWAIT, &err);
1476 if (!skb)
1477 return ERR_PTR(err);
1478
1479 /* Create L2CAP header */
1480 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
1481 lh->cid = cpu_to_le16(chan->dcid);
1482 lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));
1483 put_unaligned_le16(chan->psm, skb_put(skb, 2));
1484
1485 err = l2cap_skbuff_fromiovec(sk, msg, len, count, skb);
1486 if (unlikely(err < 0)) {
1487 kfree_skb(skb);
1488 return ERR_PTR(err);
1489 }
1490 return skb;
1491 }
1492
1493 struct sk_buff *l2cap_create_basic_pdu(struct l2cap_chan *chan, struct msghdr *msg, size_t len)
1494 {
1495 struct sock *sk = chan->sk;
1496 struct l2cap_conn *conn = chan->conn;
1497 struct sk_buff *skb;
1498 int err, count, hlen = L2CAP_HDR_SIZE;
1499 struct l2cap_hdr *lh;
1500
1501 BT_DBG("sk %p len %d", sk, (int)len);
1502
1503 count = min_t(unsigned int, (conn->mtu - hlen), len);
1504 skb = bt_skb_send_alloc(sk, count + hlen,
1505 msg->msg_flags & MSG_DONTWAIT, &err);
1506 if (!skb)
1507 return ERR_PTR(err);
1508
1509 /* Create L2CAP header */
1510 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
1511 lh->cid = cpu_to_le16(chan->dcid);
1512 lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));
1513
1514 err = l2cap_skbuff_fromiovec(sk, msg, len, count, skb);
1515 if (unlikely(err < 0)) {
1516 kfree_skb(skb);
1517 return ERR_PTR(err);
1518 }
1519 return skb;
1520 }
1521
1522 struct sk_buff *l2cap_create_iframe_pdu(struct l2cap_chan *chan, struct msghdr *msg, size_t len, u16 control, u16 sdulen)
1523 {
1524 struct sock *sk = chan->sk;
1525 struct l2cap_conn *conn = chan->conn;
1526 struct sk_buff *skb;
1527 int err, count, hlen = L2CAP_HDR_SIZE + 2;
1528 struct l2cap_hdr *lh;
1529
1530 BT_DBG("sk %p len %d", sk, (int)len);
1531
1532 if (!conn)
1533 return ERR_PTR(-ENOTCONN);
1534
1535 if (sdulen)
1536 hlen += 2;
1537
1538 if (chan->fcs == L2CAP_FCS_CRC16)
1539 hlen += 2;
1540
1541 count = min_t(unsigned int, (conn->mtu - hlen), len);
1542 skb = bt_skb_send_alloc(sk, count + hlen,
1543 msg->msg_flags & MSG_DONTWAIT, &err);
1544 if (!skb)
1545 return ERR_PTR(err);
1546
1547 /* Create L2CAP header */
1548 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
1549 lh->cid = cpu_to_le16(chan->dcid);
1550 lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));
1551 put_unaligned_le16(control, skb_put(skb, 2));
1552 if (sdulen)
1553 put_unaligned_le16(sdulen, skb_put(skb, 2));
1554
1555 err = l2cap_skbuff_fromiovec(sk, msg, len, count, skb);
1556 if (unlikely(err < 0)) {
1557 kfree_skb(skb);
1558 return ERR_PTR(err);
1559 }
1560
1561 if (chan->fcs == L2CAP_FCS_CRC16)
1562 put_unaligned_le16(0, skb_put(skb, 2));
1563
1564 bt_cb(skb)->retries = 0;
1565 return skb;
1566 }
1567
1568 int l2cap_sar_segment_sdu(struct l2cap_chan *chan, struct msghdr *msg, size_t len)
1569 {
1570 struct sk_buff *skb;
1571 struct sk_buff_head sar_queue;
1572 u16 control;
1573 size_t size = 0;
1574
1575 skb_queue_head_init(&sar_queue);
1576 control = L2CAP_SDU_START;
1577 skb = l2cap_create_iframe_pdu(chan, msg, chan->remote_mps, control, len);
1578 if (IS_ERR(skb))
1579 return PTR_ERR(skb);
1580
1581 __skb_queue_tail(&sar_queue, skb);
1582 len -= chan->remote_mps;
1583 size += chan->remote_mps;
1584
1585 while (len > 0) {
1586 size_t buflen;
1587
1588 if (len > chan->remote_mps) {
1589 control = L2CAP_SDU_CONTINUE;
1590 buflen = chan->remote_mps;
1591 } else {
1592 control = L2CAP_SDU_END;
1593 buflen = len;
1594 }
1595
1596 skb = l2cap_create_iframe_pdu(chan, msg, buflen, control, 0);
1597 if (IS_ERR(skb)) {
1598 skb_queue_purge(&sar_queue);
1599 return PTR_ERR(skb);
1600 }
1601
1602 __skb_queue_tail(&sar_queue, skb);
1603 len -= buflen;
1604 size += buflen;
1605 }
1606 skb_queue_splice_tail(&sar_queue, &chan->tx_q);
1607 if (chan->tx_send_head == NULL)
1608 chan->tx_send_head = sar_queue.next;
1609
1610 return size;
1611 }
1612
1613 int l2cap_chan_send(struct l2cap_chan *chan, struct msghdr *msg, size_t len)
1614 {
1615 struct sk_buff *skb;
1616 u16 control;
1617 int err;
1618
1619 /* Connectionless channel */
1620 if (chan->chan_type == L2CAP_CHAN_CONN_LESS) {
1621 skb = l2cap_create_connless_pdu(chan, msg, len);
1622 if (IS_ERR(skb))
1623 return PTR_ERR(skb);
1624
1625 l2cap_do_send(chan, skb);
1626 return len;
1627 }
1628
1629 switch (chan->mode) {
1630 case L2CAP_MODE_BASIC:
1631 /* Check outgoing MTU */
1632 if (len > chan->omtu)
1633 return -EMSGSIZE;
1634
1635 /* Create a basic PDU */
1636 skb = l2cap_create_basic_pdu(chan, msg, len);
1637 if (IS_ERR(skb))
1638 return PTR_ERR(skb);
1639
1640 l2cap_do_send(chan, skb);
1641 err = len;
1642 break;
1643
1644 case L2CAP_MODE_ERTM:
1645 case L2CAP_MODE_STREAMING:
1646 /* Entire SDU fits into one PDU */
1647 if (len <= chan->remote_mps) {
1648 control = L2CAP_SDU_UNSEGMENTED;
1649 skb = l2cap_create_iframe_pdu(chan, msg, len, control,
1650 0);
1651 if (IS_ERR(skb))
1652 return PTR_ERR(skb);
1653
1654 __skb_queue_tail(&chan->tx_q, skb);
1655
1656 if (chan->tx_send_head == NULL)
1657 chan->tx_send_head = skb;
1658
1659 } else {
1660 /* Segment SDU into multiples PDUs */
1661 err = l2cap_sar_segment_sdu(chan, msg, len);
1662 if (err < 0)
1663 return err;
1664 }
1665
1666 if (chan->mode == L2CAP_MODE_STREAMING) {
1667 l2cap_streaming_send(chan);
1668 err = len;
1669 break;
1670 }
1671
1672 if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state) &&
1673 test_bit(CONN_WAIT_F, &chan->conn_state)) {
1674 err = len;
1675 break;
1676 }
1677
1678 err = l2cap_ertm_send(chan);
1679 if (err >= 0)
1680 err = len;
1681
1682 break;
1683
1684 default:
1685 BT_DBG("bad state %1.1x", chan->mode);
1686 err = -EBADFD;
1687 }
1688
1689 return err;
1690 }
1691
1692 /* Copy frame to all raw sockets on that connection */
1693 static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
1694 {
1695 struct sk_buff *nskb;
1696 struct l2cap_chan *chan;
1697
1698 BT_DBG("conn %p", conn);
1699
1700 read_lock(&conn->chan_lock);
1701 list_for_each_entry(chan, &conn->chan_l, list) {
1702 struct sock *sk = chan->sk;
1703 if (chan->chan_type != L2CAP_CHAN_RAW)
1704 continue;
1705
1706 /* Don't send frame to the socket it came from */
1707 if (skb->sk == sk)
1708 continue;
1709 nskb = skb_clone(skb, GFP_ATOMIC);
1710 if (!nskb)
1711 continue;
1712
1713 if (chan->ops->recv(chan->data, nskb))
1714 kfree_skb(nskb);
1715 }
1716 read_unlock(&conn->chan_lock);
1717 }
1718
1719 /* ---- L2CAP signalling commands ---- */
1720 static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
1721 u8 code, u8 ident, u16 dlen, void *data)
1722 {
1723 struct sk_buff *skb, **frag;
1724 struct l2cap_cmd_hdr *cmd;
1725 struct l2cap_hdr *lh;
1726 int len, count;
1727
1728 BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %d",
1729 conn, code, ident, dlen);
1730
1731 len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen;
1732 count = min_t(unsigned int, conn->mtu, len);
1733
1734 skb = bt_skb_alloc(count, GFP_ATOMIC);
1735 if (!skb)
1736 return NULL;
1737
1738 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
1739 lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen);
1740
1741 if (conn->hcon->type == LE_LINK)
1742 lh->cid = cpu_to_le16(L2CAP_CID_LE_SIGNALING);
1743 else
1744 lh->cid = cpu_to_le16(L2CAP_CID_SIGNALING);
1745
1746 cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE);
1747 cmd->code = code;
1748 cmd->ident = ident;
1749 cmd->len = cpu_to_le16(dlen);
1750
1751 if (dlen) {
1752 count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE;
1753 memcpy(skb_put(skb, count), data, count);
1754 data += count;
1755 }
1756
1757 len -= skb->len;
1758
1759 /* Continuation fragments (no L2CAP header) */
1760 frag = &skb_shinfo(skb)->frag_list;
1761 while (len) {
1762 count = min_t(unsigned int, conn->mtu, len);
1763
1764 *frag = bt_skb_alloc(count, GFP_ATOMIC);
1765 if (!*frag)
1766 goto fail;
1767
1768 memcpy(skb_put(*frag, count), data, count);
1769
1770 len -= count;
1771 data += count;
1772
1773 frag = &(*frag)->next;
1774 }
1775
1776 return skb;
1777
1778 fail:
1779 kfree_skb(skb);
1780 return NULL;
1781 }
1782
1783 static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, unsigned long *val)
1784 {
1785 struct l2cap_conf_opt *opt = *ptr;
1786 int len;
1787
1788 len = L2CAP_CONF_OPT_SIZE + opt->len;
1789 *ptr += len;
1790
1791 *type = opt->type;
1792 *olen = opt->len;
1793
1794 switch (opt->len) {
1795 case 1:
1796 *val = *((u8 *) opt->val);
1797 break;
1798
1799 case 2:
1800 *val = get_unaligned_le16(opt->val);
1801 break;
1802
1803 case 4:
1804 *val = get_unaligned_le32(opt->val);
1805 break;
1806
1807 default:
1808 *val = (unsigned long) opt->val;
1809 break;
1810 }
1811
1812 BT_DBG("type 0x%2.2x len %d val 0x%lx", *type, opt->len, *val);
1813 return len;
1814 }
1815
1816 static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val)
1817 {
1818 struct l2cap_conf_opt *opt = *ptr;
1819
1820 BT_DBG("type 0x%2.2x len %d val 0x%lx", type, len, val);
1821
1822 opt->type = type;
1823 opt->len = len;
1824
1825 switch (len) {
1826 case 1:
1827 *((u8 *) opt->val) = val;
1828 break;
1829
1830 case 2:
1831 put_unaligned_le16(val, opt->val);
1832 break;
1833
1834 case 4:
1835 put_unaligned_le32(val, opt->val);
1836 break;
1837
1838 default:
1839 memcpy(opt->val, (void *) val, len);
1840 break;
1841 }
1842
1843 *ptr += L2CAP_CONF_OPT_SIZE + len;
1844 }
1845
1846 static void l2cap_ack_timeout(unsigned long arg)
1847 {
1848 struct l2cap_chan *chan = (void *) arg;
1849
1850 bh_lock_sock(chan->sk);
1851 l2cap_send_ack(chan);
1852 bh_unlock_sock(chan->sk);
1853 }
1854
1855 static inline void l2cap_ertm_init(struct l2cap_chan *chan)
1856 {
1857 struct sock *sk = chan->sk;
1858
1859 chan->expected_ack_seq = 0;
1860 chan->unacked_frames = 0;
1861 chan->buffer_seq = 0;
1862 chan->num_acked = 0;
1863 chan->frames_sent = 0;
1864
1865 setup_timer(&chan->retrans_timer, l2cap_retrans_timeout,
1866 (unsigned long) chan);
1867 setup_timer(&chan->monitor_timer, l2cap_monitor_timeout,
1868 (unsigned long) chan);
1869 setup_timer(&chan->ack_timer, l2cap_ack_timeout, (unsigned long) chan);
1870
1871 skb_queue_head_init(&chan->srej_q);
1872
1873 INIT_LIST_HEAD(&chan->srej_l);
1874
1875
1876 sk->sk_backlog_rcv = l2cap_ertm_data_rcv;
1877 }
1878
1879 static inline __u8 l2cap_select_mode(__u8 mode, __u16 remote_feat_mask)
1880 {
1881 switch (mode) {
1882 case L2CAP_MODE_STREAMING:
1883 case L2CAP_MODE_ERTM:
1884 if (l2cap_mode_supported(mode, remote_feat_mask))
1885 return mode;
1886 /* fall through */
1887 default:
1888 return L2CAP_MODE_BASIC;
1889 }
1890 }
1891
1892 static int l2cap_build_conf_req(struct l2cap_chan *chan, void *data)
1893 {
1894 struct l2cap_conf_req *req = data;
1895 struct l2cap_conf_rfc rfc = { .mode = chan->mode };
1896 void *ptr = req->data;
1897
1898 BT_DBG("chan %p", chan);
1899
1900 if (chan->num_conf_req || chan->num_conf_rsp)
1901 goto done;
1902
1903 switch (chan->mode) {
1904 case L2CAP_MODE_STREAMING:
1905 case L2CAP_MODE_ERTM:
1906 if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state))
1907 break;
1908
1909 /* fall through */
1910 default:
1911 chan->mode = l2cap_select_mode(rfc.mode, chan->conn->feat_mask);
1912 break;
1913 }
1914
1915 done:
1916 if (chan->imtu != L2CAP_DEFAULT_MTU)
1917 l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu);
1918
1919 switch (chan->mode) {
1920 case L2CAP_MODE_BASIC:
1921 if (!(chan->conn->feat_mask & L2CAP_FEAT_ERTM) &&
1922 !(chan->conn->feat_mask & L2CAP_FEAT_STREAMING))
1923 break;
1924
1925 rfc.mode = L2CAP_MODE_BASIC;
1926 rfc.txwin_size = 0;
1927 rfc.max_transmit = 0;
1928 rfc.retrans_timeout = 0;
1929 rfc.monitor_timeout = 0;
1930 rfc.max_pdu_size = 0;
1931
1932 l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
1933 (unsigned long) &rfc);
1934 break;
1935
1936 case L2CAP_MODE_ERTM:
1937 rfc.mode = L2CAP_MODE_ERTM;
1938 rfc.txwin_size = chan->tx_win;
1939 rfc.max_transmit = chan->max_tx;
1940 rfc.retrans_timeout = 0;
1941 rfc.monitor_timeout = 0;
1942 rfc.max_pdu_size = cpu_to_le16(L2CAP_DEFAULT_MAX_PDU_SIZE);
1943 if (L2CAP_DEFAULT_MAX_PDU_SIZE > chan->conn->mtu - 10)
1944 rfc.max_pdu_size = cpu_to_le16(chan->conn->mtu - 10);
1945
1946 l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
1947 (unsigned long) &rfc);
1948
1949 if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS))
1950 break;
1951
1952 if (chan->fcs == L2CAP_FCS_NONE ||
1953 test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) {
1954 chan->fcs = L2CAP_FCS_NONE;
1955 l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs);
1956 }
1957 break;
1958
1959 case L2CAP_MODE_STREAMING:
1960 rfc.mode = L2CAP_MODE_STREAMING;
1961 rfc.txwin_size = 0;
1962 rfc.max_transmit = 0;
1963 rfc.retrans_timeout = 0;
1964 rfc.monitor_timeout = 0;
1965 rfc.max_pdu_size = cpu_to_le16(L2CAP_DEFAULT_MAX_PDU_SIZE);
1966 if (L2CAP_DEFAULT_MAX_PDU_SIZE > chan->conn->mtu - 10)
1967 rfc.max_pdu_size = cpu_to_le16(chan->conn->mtu - 10);
1968
1969 l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC, sizeof(rfc),
1970 (unsigned long) &rfc);
1971
1972 if (!(chan->conn->feat_mask & L2CAP_FEAT_FCS))
1973 break;
1974
1975 if (chan->fcs == L2CAP_FCS_NONE ||
1976 test_bit(CONF_NO_FCS_RECV, &chan->conf_state)) {
1977 chan->fcs = L2CAP_FCS_NONE;
1978 l2cap_add_conf_opt(&ptr, L2CAP_CONF_FCS, 1, chan->fcs);
1979 }
1980 break;
1981 }
1982
1983 req->dcid = cpu_to_le16(chan->dcid);
1984 req->flags = cpu_to_le16(0);
1985
1986 return ptr - data;
1987 }
1988
1989 static int l2cap_parse_conf_req(struct l2cap_chan *chan, void *data)
1990 {
1991 struct l2cap_conf_rsp *rsp = data;
1992 void *ptr = rsp->data;
1993 void *req = chan->conf_req;
1994 int len = chan->conf_len;
1995 int type, hint, olen;
1996 unsigned long val;
1997 struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC };
1998 u16 mtu = L2CAP_DEFAULT_MTU;
1999 u16 result = L2CAP_CONF_SUCCESS;
2000
2001 BT_DBG("chan %p", chan);
2002
2003 while (len >= L2CAP_CONF_OPT_SIZE) {
2004 len -= l2cap_get_conf_opt(&req, &type, &olen, &val);
2005
2006 hint = type & L2CAP_CONF_HINT;
2007 type &= L2CAP_CONF_MASK;
2008
2009 switch (type) {
2010 case L2CAP_CONF_MTU:
2011 mtu = val;
2012 break;
2013
2014 case L2CAP_CONF_FLUSH_TO:
2015 chan->flush_to = val;
2016 break;
2017
2018 case L2CAP_CONF_QOS:
2019 break;
2020
2021 case L2CAP_CONF_RFC:
2022 if (olen == sizeof(rfc))
2023 memcpy(&rfc, (void *) val, olen);
2024 break;
2025
2026 case L2CAP_CONF_FCS:
2027 if (val == L2CAP_FCS_NONE)
2028 set_bit(CONF_NO_FCS_RECV, &chan->conf_state);
2029
2030 break;
2031
2032 default:
2033 if (hint)
2034 break;
2035
2036 result = L2CAP_CONF_UNKNOWN;
2037 *((u8 *) ptr++) = type;
2038 break;
2039 }
2040 }
2041
2042 if (chan->num_conf_rsp || chan->num_conf_req > 1)
2043 goto done;
2044
2045 switch (chan->mode) {
2046 case L2CAP_MODE_STREAMING:
2047 case L2CAP_MODE_ERTM:
2048 if (!test_bit(CONF_STATE2_DEVICE, &chan->conf_state)) {
2049 chan->mode = l2cap_select_mode(rfc.mode,
2050 chan->conn->feat_mask);
2051 break;
2052 }
2053
2054 if (chan->mode != rfc.mode)
2055 return -ECONNREFUSED;
2056
2057 break;
2058 }
2059
2060 done:
2061 if (chan->mode != rfc.mode) {
2062 result = L2CAP_CONF_UNACCEPT;
2063 rfc.mode = chan->mode;
2064
2065 if (chan->num_conf_rsp == 1)
2066 return -ECONNREFUSED;
2067
2068 l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC,
2069 sizeof(rfc), (unsigned long) &rfc);
2070 }
2071
2072
2073 if (result == L2CAP_CONF_SUCCESS) {
2074 /* Configure output options and let the other side know
2075 * which ones we don't like. */
2076
2077 if (mtu < L2CAP_DEFAULT_MIN_MTU)
2078 result = L2CAP_CONF_UNACCEPT;
2079 else {
2080 chan->omtu = mtu;
2081 set_bit(CONF_MTU_DONE, &chan->conf_state);
2082 }
2083 l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->omtu);
2084
2085 switch (rfc.mode) {
2086 case L2CAP_MODE_BASIC:
2087 chan->fcs = L2CAP_FCS_NONE;
2088 set_bit(CONF_MODE_DONE, &chan->conf_state);
2089 break;
2090
2091 case L2CAP_MODE_ERTM:
2092 chan->remote_tx_win = rfc.txwin_size;
2093 chan->remote_max_tx = rfc.max_transmit;
2094
2095 if (le16_to_cpu(rfc.max_pdu_size) > chan->conn->mtu - 10)
2096 rfc.max_pdu_size = cpu_to_le16(chan->conn->mtu - 10);
2097
2098 chan->remote_mps = le16_to_cpu(rfc.max_pdu_size);
2099
2100 rfc.retrans_timeout =
2101 le16_to_cpu(L2CAP_DEFAULT_RETRANS_TO);
2102 rfc.monitor_timeout =
2103 le16_to_cpu(L2CAP_DEFAULT_MONITOR_TO);
2104
2105 set_bit(CONF_MODE_DONE, &chan->conf_state);
2106
2107 l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC,
2108 sizeof(rfc), (unsigned long) &rfc);
2109
2110 break;
2111
2112 case L2CAP_MODE_STREAMING:
2113 if (le16_to_cpu(rfc.max_pdu_size) > chan->conn->mtu - 10)
2114 rfc.max_pdu_size = cpu_to_le16(chan->conn->mtu - 10);
2115
2116 chan->remote_mps = le16_to_cpu(rfc.max_pdu_size);
2117
2118 set_bit(CONF_MODE_DONE, &chan->conf_state);
2119
2120 l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC,
2121 sizeof(rfc), (unsigned long) &rfc);
2122
2123 break;
2124
2125 default:
2126 result = L2CAP_CONF_UNACCEPT;
2127
2128 memset(&rfc, 0, sizeof(rfc));
2129 rfc.mode = chan->mode;
2130 }
2131
2132 if (result == L2CAP_CONF_SUCCESS)
2133 set_bit(CONF_OUTPUT_DONE, &chan->conf_state);
2134 }
2135 rsp->scid = cpu_to_le16(chan->dcid);
2136 rsp->result = cpu_to_le16(result);
2137 rsp->flags = cpu_to_le16(0x0000);
2138
2139 return ptr - data;
2140 }
2141
2142 static int l2cap_parse_conf_rsp(struct l2cap_chan *chan, void *rsp, int len, void *data, u16 *result)
2143 {
2144 struct l2cap_conf_req *req = data;
2145 void *ptr = req->data;
2146 int type, olen;
2147 unsigned long val;
2148 struct l2cap_conf_rfc rfc;
2149
2150 BT_DBG("chan %p, rsp %p, len %d, req %p", chan, rsp, len, data);
2151
2152 while (len >= L2CAP_CONF_OPT_SIZE) {
2153 len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val);
2154
2155 switch (type) {
2156 case L2CAP_CONF_MTU:
2157 if (val < L2CAP_DEFAULT_MIN_MTU) {
2158 *result = L2CAP_CONF_UNACCEPT;
2159 chan->imtu = L2CAP_DEFAULT_MIN_MTU;
2160 } else
2161 chan->imtu = val;
2162 l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, chan->imtu);
2163 break;
2164
2165 case L2CAP_CONF_FLUSH_TO:
2166 chan->flush_to = val;
2167 l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO,
2168 2, chan->flush_to);
2169 break;
2170
2171 case L2CAP_CONF_RFC:
2172 if (olen == sizeof(rfc))
2173 memcpy(&rfc, (void *)val, olen);
2174
2175 if (test_bit(CONF_STATE2_DEVICE, &chan->conf_state) &&
2176 rfc.mode != chan->mode)
2177 return -ECONNREFUSED;
2178
2179 chan->fcs = 0;
2180
2181 l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC,
2182 sizeof(rfc), (unsigned long) &rfc);
2183 break;
2184 }
2185 }
2186
2187 if (chan->mode == L2CAP_MODE_BASIC && chan->mode != rfc.mode)
2188 return -ECONNREFUSED;
2189
2190 chan->mode = rfc.mode;
2191
2192 if (*result == L2CAP_CONF_SUCCESS) {
2193 switch (rfc.mode) {
2194 case L2CAP_MODE_ERTM:
2195 chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout);
2196 chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout);
2197 chan->mps = le16_to_cpu(rfc.max_pdu_size);
2198 break;
2199 case L2CAP_MODE_STREAMING:
2200 chan->mps = le16_to_cpu(rfc.max_pdu_size);
2201 }
2202 }
2203
2204 req->dcid = cpu_to_le16(chan->dcid);
2205 req->flags = cpu_to_le16(0x0000);
2206
2207 return ptr - data;
2208 }
2209
2210 static int l2cap_build_conf_rsp(struct l2cap_chan *chan, void *data, u16 result, u16 flags)
2211 {
2212 struct l2cap_conf_rsp *rsp = data;
2213 void *ptr = rsp->data;
2214
2215 BT_DBG("chan %p", chan);
2216
2217 rsp->scid = cpu_to_le16(chan->dcid);
2218 rsp->result = cpu_to_le16(result);
2219 rsp->flags = cpu_to_le16(flags);
2220
2221 return ptr - data;
2222 }
2223
2224 void __l2cap_connect_rsp_defer(struct l2cap_chan *chan)
2225 {
2226 struct l2cap_conn_rsp rsp;
2227 struct l2cap_conn *conn = chan->conn;
2228 u8 buf[128];
2229
2230 rsp.scid = cpu_to_le16(chan->dcid);
2231 rsp.dcid = cpu_to_le16(chan->scid);
2232 rsp.result = cpu_to_le16(L2CAP_CR_SUCCESS);
2233 rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
2234 l2cap_send_cmd(conn, chan->ident,
2235 L2CAP_CONN_RSP, sizeof(rsp), &rsp);
2236
2237 if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state))
2238 return;
2239
2240 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
2241 l2cap_build_conf_req(chan, buf), buf);
2242 chan->num_conf_req++;
2243 }
2244
2245 static void l2cap_conf_rfc_get(struct l2cap_chan *chan, void *rsp, int len)
2246 {
2247 int type, olen;
2248 unsigned long val;
2249 struct l2cap_conf_rfc rfc;
2250
2251 BT_DBG("chan %p, rsp %p, len %d", chan, rsp, len);
2252
2253 if ((chan->mode != L2CAP_MODE_ERTM) && (chan->mode != L2CAP_MODE_STREAMING))
2254 return;
2255
2256 while (len >= L2CAP_CONF_OPT_SIZE) {
2257 len -= l2cap_get_conf_opt(&rsp, &type, &olen, &val);
2258
2259 switch (type) {
2260 case L2CAP_CONF_RFC:
2261 if (olen == sizeof(rfc))
2262 memcpy(&rfc, (void *)val, olen);
2263 goto done;
2264 }
2265 }
2266
2267 done:
2268 switch (rfc.mode) {
2269 case L2CAP_MODE_ERTM:
2270 chan->retrans_timeout = le16_to_cpu(rfc.retrans_timeout);
2271 chan->monitor_timeout = le16_to_cpu(rfc.monitor_timeout);
2272 chan->mps = le16_to_cpu(rfc.max_pdu_size);
2273 break;
2274 case L2CAP_MODE_STREAMING:
2275 chan->mps = le16_to_cpu(rfc.max_pdu_size);
2276 }
2277 }
2278
2279 static inline int l2cap_command_rej(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
2280 {
2281 struct l2cap_cmd_rej_unk *rej = (struct l2cap_cmd_rej_unk *) data;
2282
2283 if (rej->reason != L2CAP_REJ_NOT_UNDERSTOOD)
2284 return 0;
2285
2286 if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) &&
2287 cmd->ident == conn->info_ident) {
2288 del_timer(&conn->info_timer);
2289
2290 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
2291 conn->info_ident = 0;
2292
2293 l2cap_conn_start(conn);
2294 }
2295
2296 return 0;
2297 }
2298
2299 static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
2300 {
2301 struct l2cap_conn_req *req = (struct l2cap_conn_req *) data;
2302 struct l2cap_conn_rsp rsp;
2303 struct l2cap_chan *chan = NULL, *pchan;
2304 struct sock *parent, *sk = NULL;
2305 int result, status = L2CAP_CS_NO_INFO;
2306
2307 u16 dcid = 0, scid = __le16_to_cpu(req->scid);
2308 __le16 psm = req->psm;
2309
2310 BT_DBG("psm 0x%2.2x scid 0x%4.4x", psm, scid);
2311
2312 /* Check if we have socket listening on psm */
2313 pchan = l2cap_global_chan_by_psm(BT_LISTEN, psm, conn->src);
2314 if (!pchan) {
2315 result = L2CAP_CR_BAD_PSM;
2316 goto sendresp;
2317 }
2318
2319 parent = pchan->sk;
2320
2321 bh_lock_sock(parent);
2322
2323 /* Check if the ACL is secure enough (if not SDP) */
2324 if (psm != cpu_to_le16(0x0001) &&
2325 !hci_conn_check_link_mode(conn->hcon)) {
2326 conn->disc_reason = 0x05;
2327 result = L2CAP_CR_SEC_BLOCK;
2328 goto response;
2329 }
2330
2331 result = L2CAP_CR_NO_MEM;
2332
2333 /* Check for backlog size */
2334 if (sk_acceptq_is_full(parent)) {
2335 BT_DBG("backlog full %d", parent->sk_ack_backlog);
2336 goto response;
2337 }
2338
2339 chan = pchan->ops->new_connection(pchan->data);
2340 if (!chan)
2341 goto response;
2342
2343 sk = chan->sk;
2344
2345 write_lock_bh(&conn->chan_lock);
2346
2347 /* Check if we already have channel with that dcid */
2348 if (__l2cap_get_chan_by_dcid(conn, scid)) {
2349 write_unlock_bh(&conn->chan_lock);
2350 sock_set_flag(sk, SOCK_ZAPPED);
2351 chan->ops->close(chan->data);
2352 goto response;
2353 }
2354
2355 hci_conn_hold(conn->hcon);
2356
2357 bacpy(&bt_sk(sk)->src, conn->src);
2358 bacpy(&bt_sk(sk)->dst, conn->dst);
2359 chan->psm = psm;
2360 chan->dcid = scid;
2361
2362 bt_accept_enqueue(parent, sk);
2363
2364 __l2cap_chan_add(conn, chan);
2365
2366 dcid = chan->scid;
2367
2368 __set_chan_timer(chan, sk->sk_sndtimeo);
2369
2370 chan->ident = cmd->ident;
2371
2372 if (conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE) {
2373 if (l2cap_check_security(chan)) {
2374 if (bt_sk(sk)->defer_setup) {
2375 l2cap_state_change(chan, BT_CONNECT2);
2376 result = L2CAP_CR_PEND;
2377 status = L2CAP_CS_AUTHOR_PEND;
2378 parent->sk_data_ready(parent, 0);
2379 } else {
2380 l2cap_state_change(chan, BT_CONFIG);
2381 result = L2CAP_CR_SUCCESS;
2382 status = L2CAP_CS_NO_INFO;
2383 }
2384 } else {
2385 l2cap_state_change(chan, BT_CONNECT2);
2386 result = L2CAP_CR_PEND;
2387 status = L2CAP_CS_AUTHEN_PEND;
2388 }
2389 } else {
2390 l2cap_state_change(chan, BT_CONNECT2);
2391 result = L2CAP_CR_PEND;
2392 status = L2CAP_CS_NO_INFO;
2393 }
2394
2395 write_unlock_bh(&conn->chan_lock);
2396
2397 response:
2398 bh_unlock_sock(parent);
2399
2400 sendresp:
2401 rsp.scid = cpu_to_le16(scid);
2402 rsp.dcid = cpu_to_le16(dcid);
2403 rsp.result = cpu_to_le16(result);
2404 rsp.status = cpu_to_le16(status);
2405 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp);
2406
2407 if (result == L2CAP_CR_PEND && status == L2CAP_CS_NO_INFO) {
2408 struct l2cap_info_req info;
2409 info.type = cpu_to_le16(L2CAP_IT_FEAT_MASK);
2410
2411 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT;
2412 conn->info_ident = l2cap_get_ident(conn);
2413
2414 mod_timer(&conn->info_timer, jiffies +
2415 msecs_to_jiffies(L2CAP_INFO_TIMEOUT));
2416
2417 l2cap_send_cmd(conn, conn->info_ident,
2418 L2CAP_INFO_REQ, sizeof(info), &info);
2419 }
2420
2421 if (chan && !test_bit(CONF_REQ_SENT, &chan->conf_state) &&
2422 result == L2CAP_CR_SUCCESS) {
2423 u8 buf[128];
2424 set_bit(CONF_REQ_SENT, &chan->conf_state);
2425 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
2426 l2cap_build_conf_req(chan, buf), buf);
2427 chan->num_conf_req++;
2428 }
2429
2430 return 0;
2431 }
2432
2433 static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
2434 {
2435 struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data;
2436 u16 scid, dcid, result, status;
2437 struct l2cap_chan *chan;
2438 struct sock *sk;
2439 u8 req[128];
2440
2441 scid = __le16_to_cpu(rsp->scid);
2442 dcid = __le16_to_cpu(rsp->dcid);
2443 result = __le16_to_cpu(rsp->result);
2444 status = __le16_to_cpu(rsp->status);
2445
2446 BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", dcid, scid, result, status);
2447
2448 if (scid) {
2449 chan = l2cap_get_chan_by_scid(conn, scid);
2450 if (!chan)
2451 return -EFAULT;
2452 } else {
2453 chan = l2cap_get_chan_by_ident(conn, cmd->ident);
2454 if (!chan)
2455 return -EFAULT;
2456 }
2457
2458 sk = chan->sk;
2459
2460 switch (result) {
2461 case L2CAP_CR_SUCCESS:
2462 l2cap_state_change(chan, BT_CONFIG);
2463 chan->ident = 0;
2464 chan->dcid = dcid;
2465 clear_bit(CONF_CONNECT_PEND, &chan->conf_state);
2466
2467 if (test_and_set_bit(CONF_REQ_SENT, &chan->conf_state))
2468 break;
2469
2470 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
2471 l2cap_build_conf_req(chan, req), req);
2472 chan->num_conf_req++;
2473 break;
2474
2475 case L2CAP_CR_PEND:
2476 set_bit(CONF_CONNECT_PEND, &chan->conf_state);
2477 break;
2478
2479 default:
2480 /* don't delete l2cap channel if sk is owned by user */
2481 if (sock_owned_by_user(sk)) {
2482 l2cap_state_change(chan, BT_DISCONN);
2483 __clear_chan_timer(chan);
2484 __set_chan_timer(chan, HZ / 5);
2485 break;
2486 }
2487
2488 l2cap_chan_del(chan, ECONNREFUSED);
2489 break;
2490 }
2491
2492 bh_unlock_sock(sk);
2493 return 0;
2494 }
2495
2496 static inline void set_default_fcs(struct l2cap_chan *chan)
2497 {
2498 /* FCS is enabled only in ERTM or streaming mode, if one or both
2499 * sides request it.
2500 */
2501 if (chan->mode != L2CAP_MODE_ERTM && chan->mode != L2CAP_MODE_STREAMING)
2502 chan->fcs = L2CAP_FCS_NONE;
2503 else if (!test_bit(CONF_NO_FCS_RECV, &chan->conf_state))
2504 chan->fcs = L2CAP_FCS_CRC16;
2505 }
2506
2507 static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data)
2508 {
2509 struct l2cap_conf_req *req = (struct l2cap_conf_req *) data;
2510 u16 dcid, flags;
2511 u8 rsp[64];
2512 struct l2cap_chan *chan;
2513 struct sock *sk;
2514 int len;
2515
2516 dcid = __le16_to_cpu(req->dcid);
2517 flags = __le16_to_cpu(req->flags);
2518
2519 BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags);
2520
2521 chan = l2cap_get_chan_by_scid(conn, dcid);
2522 if (!chan)
2523 return -ENOENT;
2524
2525 sk = chan->sk;
2526
2527 if (chan->state != BT_CONFIG && chan->state != BT_CONNECT2) {
2528 struct l2cap_cmd_rej_cid rej;
2529
2530 rej.reason = cpu_to_le16(L2CAP_REJ_INVALID_CID);
2531 rej.scid = cpu_to_le16(chan->scid);
2532 rej.dcid = cpu_to_le16(chan->dcid);
2533
2534 l2cap_send_cmd(conn, cmd->ident, L2CAP_COMMAND_REJ,
2535 sizeof(rej), &rej);
2536 goto unlock;
2537 }
2538
2539 /* Reject if config buffer is too small. */
2540 len = cmd_len - sizeof(*req);
2541 if (len < 0 || chan->conf_len + len > sizeof(chan->conf_req)) {
2542 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
2543 l2cap_build_conf_rsp(chan, rsp,
2544 L2CAP_CONF_REJECT, flags), rsp);
2545 goto unlock;
2546 }
2547
2548 /* Store config. */
2549 memcpy(chan->conf_req + chan->conf_len, req->data, len);
2550 chan->conf_len += len;
2551
2552 if (flags & 0x0001) {
2553 /* Incomplete config. Send empty response. */
2554 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
2555 l2cap_build_conf_rsp(chan, rsp,
2556 L2CAP_CONF_SUCCESS, 0x0001), rsp);
2557 goto unlock;
2558 }
2559
2560 /* Complete config. */
2561 len = l2cap_parse_conf_req(chan, rsp);
2562 if (len < 0) {
2563 l2cap_send_disconn_req(conn, chan, ECONNRESET);
2564 goto unlock;
2565 }
2566
2567 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp);
2568 chan->num_conf_rsp++;
2569
2570 /* Reset config buffer. */
2571 chan->conf_len = 0;
2572
2573 if (!test_bit(CONF_OUTPUT_DONE, &chan->conf_state))
2574 goto unlock;
2575
2576 if (test_bit(CONF_INPUT_DONE, &chan->conf_state)) {
2577 set_default_fcs(chan);
2578
2579 l2cap_state_change(chan, BT_CONNECTED);
2580
2581 chan->next_tx_seq = 0;
2582 chan->expected_tx_seq = 0;
2583 skb_queue_head_init(&chan->tx_q);
2584 if (chan->mode == L2CAP_MODE_ERTM)
2585 l2cap_ertm_init(chan);
2586
2587 l2cap_chan_ready(sk);
2588 goto unlock;
2589 }
2590
2591 if (!test_and_set_bit(CONF_REQ_SENT, &chan->conf_state)) {
2592 u8 buf[64];
2593 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
2594 l2cap_build_conf_req(chan, buf), buf);
2595 chan->num_conf_req++;
2596 }
2597
2598 unlock:
2599 bh_unlock_sock(sk);
2600 return 0;
2601 }
2602
2603 static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
2604 {
2605 struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data;
2606 u16 scid, flags, result;
2607 struct l2cap_chan *chan;
2608 struct sock *sk;
2609 int len = cmd->len - sizeof(*rsp);
2610
2611 scid = __le16_to_cpu(rsp->scid);
2612 flags = __le16_to_cpu(rsp->flags);
2613 result = __le16_to_cpu(rsp->result);
2614
2615 BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x",
2616 scid, flags, result);
2617
2618 chan = l2cap_get_chan_by_scid(conn, scid);
2619 if (!chan)
2620 return 0;
2621
2622 sk = chan->sk;
2623
2624 switch (result) {
2625 case L2CAP_CONF_SUCCESS:
2626 l2cap_conf_rfc_get(chan, rsp->data, len);
2627 break;
2628
2629 case L2CAP_CONF_UNACCEPT:
2630 if (chan->num_conf_rsp <= L2CAP_CONF_MAX_CONF_RSP) {
2631 char req[64];
2632
2633 if (len > sizeof(req) - sizeof(struct l2cap_conf_req)) {
2634 l2cap_send_disconn_req(conn, chan, ECONNRESET);
2635 goto done;
2636 }
2637
2638 /* throw out any old stored conf requests */
2639 result = L2CAP_CONF_SUCCESS;
2640 len = l2cap_parse_conf_rsp(chan, rsp->data, len,
2641 req, &result);
2642 if (len < 0) {
2643 l2cap_send_disconn_req(conn, chan, ECONNRESET);
2644 goto done;
2645 }
2646
2647 l2cap_send_cmd(conn, l2cap_get_ident(conn),
2648 L2CAP_CONF_REQ, len, req);
2649 chan->num_conf_req++;
2650 if (result != L2CAP_CONF_SUCCESS)
2651 goto done;
2652 break;
2653 }
2654
2655 default:
2656 sk->sk_err = ECONNRESET;
2657 __set_chan_timer(chan, HZ * 5);
2658 l2cap_send_disconn_req(conn, chan, ECONNRESET);
2659 goto done;
2660 }
2661
2662 if (flags & 0x01)
2663 goto done;
2664
2665 set_bit(CONF_INPUT_DONE, &chan->conf_state);
2666
2667 if (test_bit(CONF_OUTPUT_DONE, &chan->conf_state)) {
2668 set_default_fcs(chan);
2669
2670 l2cap_state_change(chan, BT_CONNECTED);
2671 chan->next_tx_seq = 0;
2672 chan->expected_tx_seq = 0;
2673 skb_queue_head_init(&chan->tx_q);
2674 if (chan->mode == L2CAP_MODE_ERTM)
2675 l2cap_ertm_init(chan);
2676
2677 l2cap_chan_ready(sk);
2678 }
2679
2680 done:
2681 bh_unlock_sock(sk);
2682 return 0;
2683 }
2684
2685 static inline int l2cap_disconnect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
2686 {
2687 struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data;
2688 struct l2cap_disconn_rsp rsp;
2689 u16 dcid, scid;
2690 struct l2cap_chan *chan;
2691 struct sock *sk;
2692
2693 scid = __le16_to_cpu(req->scid);
2694 dcid = __le16_to_cpu(req->dcid);
2695
2696 BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid);
2697
2698 chan = l2cap_get_chan_by_scid(conn, dcid);
2699 if (!chan)
2700 return 0;
2701
2702 sk = chan->sk;
2703
2704 rsp.dcid = cpu_to_le16(chan->scid);
2705 rsp.scid = cpu_to_le16(chan->dcid);
2706 l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp);
2707
2708 sk->sk_shutdown = SHUTDOWN_MASK;
2709
2710 /* don't delete l2cap channel if sk is owned by user */
2711 if (sock_owned_by_user(sk)) {
2712 l2cap_state_change(chan, BT_DISCONN);
2713 __clear_chan_timer(chan);
2714 __set_chan_timer(chan, HZ / 5);
2715 bh_unlock_sock(sk);
2716 return 0;
2717 }
2718
2719 l2cap_chan_del(chan, ECONNRESET);
2720 bh_unlock_sock(sk);
2721
2722 chan->ops->close(chan->data);
2723 return 0;
2724 }
2725
2726 static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
2727 {
2728 struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data;
2729 u16 dcid, scid;
2730 struct l2cap_chan *chan;
2731 struct sock *sk;
2732
2733 scid = __le16_to_cpu(rsp->scid);
2734 dcid = __le16_to_cpu(rsp->dcid);
2735
2736 BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid);
2737
2738 chan = l2cap_get_chan_by_scid(conn, scid);
2739 if (!chan)
2740 return 0;
2741
2742 sk = chan->sk;
2743
2744 /* don't delete l2cap channel if sk is owned by user */
2745 if (sock_owned_by_user(sk)) {
2746 l2cap_state_change(chan,BT_DISCONN);
2747 __clear_chan_timer(chan);
2748 __set_chan_timer(chan, HZ / 5);
2749 bh_unlock_sock(sk);
2750 return 0;
2751 }
2752
2753 l2cap_chan_del(chan, 0);
2754 bh_unlock_sock(sk);
2755
2756 chan->ops->close(chan->data);
2757 return 0;
2758 }
2759
2760 static inline int l2cap_information_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
2761 {
2762 struct l2cap_info_req *req = (struct l2cap_info_req *) data;
2763 u16 type;
2764
2765 type = __le16_to_cpu(req->type);
2766
2767 BT_DBG("type 0x%4.4x", type);
2768
2769 if (type == L2CAP_IT_FEAT_MASK) {
2770 u8 buf[8];
2771 u32 feat_mask = l2cap_feat_mask;
2772 struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf;
2773 rsp->type = cpu_to_le16(L2CAP_IT_FEAT_MASK);
2774 rsp->result = cpu_to_le16(L2CAP_IR_SUCCESS);
2775 if (!disable_ertm)
2776 feat_mask |= L2CAP_FEAT_ERTM | L2CAP_FEAT_STREAMING
2777 | L2CAP_FEAT_FCS;
2778 put_unaligned_le32(feat_mask, rsp->data);
2779 l2cap_send_cmd(conn, cmd->ident,
2780 L2CAP_INFO_RSP, sizeof(buf), buf);
2781 } else if (type == L2CAP_IT_FIXED_CHAN) {
2782 u8 buf[12];
2783 struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf;
2784 rsp->type = cpu_to_le16(L2CAP_IT_FIXED_CHAN);
2785 rsp->result = cpu_to_le16(L2CAP_IR_SUCCESS);
2786 memcpy(buf + 4, l2cap_fixed_chan, 8);
2787 l2cap_send_cmd(conn, cmd->ident,
2788 L2CAP_INFO_RSP, sizeof(buf), buf);
2789 } else {
2790 struct l2cap_info_rsp rsp;
2791 rsp.type = cpu_to_le16(type);
2792 rsp.result = cpu_to_le16(L2CAP_IR_NOTSUPP);
2793 l2cap_send_cmd(conn, cmd->ident,
2794 L2CAP_INFO_RSP, sizeof(rsp), &rsp);
2795 }
2796
2797 return 0;
2798 }
2799
2800 static inline int l2cap_information_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
2801 {
2802 struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data;
2803 u16 type, result;
2804
2805 type = __le16_to_cpu(rsp->type);
2806 result = __le16_to_cpu(rsp->result);
2807
2808 BT_DBG("type 0x%4.4x result 0x%2.2x", type, result);
2809
2810 /* L2CAP Info req/rsp are unbound to channels, add extra checks */
2811 if (cmd->ident != conn->info_ident ||
2812 conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_DONE)
2813 return 0;
2814
2815 del_timer(&conn->info_timer);
2816
2817 if (result != L2CAP_IR_SUCCESS) {
2818 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
2819 conn->info_ident = 0;
2820
2821 l2cap_conn_start(conn);
2822
2823 return 0;
2824 }
2825
2826 if (type == L2CAP_IT_FEAT_MASK) {
2827 conn->feat_mask = get_unaligned_le32(rsp->data);
2828
2829 if (conn->feat_mask & L2CAP_FEAT_FIXED_CHAN) {
2830 struct l2cap_info_req req;
2831 req.type = cpu_to_le16(L2CAP_IT_FIXED_CHAN);
2832
2833 conn->info_ident = l2cap_get_ident(conn);
2834
2835 l2cap_send_cmd(conn, conn->info_ident,
2836 L2CAP_INFO_REQ, sizeof(req), &req);
2837 } else {
2838 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
2839 conn->info_ident = 0;
2840
2841 l2cap_conn_start(conn);
2842 }
2843 } else if (type == L2CAP_IT_FIXED_CHAN) {
2844 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_DONE;
2845 conn->info_ident = 0;
2846
2847 l2cap_conn_start(conn);
2848 }
2849
2850 return 0;
2851 }
2852
2853 static inline int l2cap_check_conn_param(u16 min, u16 max, u16 latency,
2854 u16 to_multiplier)
2855 {
2856 u16 max_latency;
2857
2858 if (min > max || min < 6 || max > 3200)
2859 return -EINVAL;
2860
2861 if (to_multiplier < 10 || to_multiplier > 3200)
2862 return -EINVAL;
2863
2864 if (max >= to_multiplier * 8)
2865 return -EINVAL;
2866
2867 max_latency = (to_multiplier * 8 / max) - 1;
2868 if (latency > 499 || latency > max_latency)
2869 return -EINVAL;
2870
2871 return 0;
2872 }
2873
2874 static inline int l2cap_conn_param_update_req(struct l2cap_conn *conn,
2875 struct l2cap_cmd_hdr *cmd, u8 *data)
2876 {
2877 struct hci_conn *hcon = conn->hcon;
2878 struct l2cap_conn_param_update_req *req;
2879 struct l2cap_conn_param_update_rsp rsp;
2880 u16 min, max, latency, to_multiplier, cmd_len;
2881 int err;
2882
2883 if (!(hcon->link_mode & HCI_LM_MASTER))
2884 return -EINVAL;
2885
2886 cmd_len = __le16_to_cpu(cmd->len);
2887 if (cmd_len != sizeof(struct l2cap_conn_param_update_req))
2888 return -EPROTO;
2889
2890 req = (struct l2cap_conn_param_update_req *) data;
2891 min = __le16_to_cpu(req->min);
2892 max = __le16_to_cpu(req->max);
2893 latency = __le16_to_cpu(req->latency);
2894 to_multiplier = __le16_to_cpu(req->to_multiplier);
2895
2896 BT_DBG("min 0x%4.4x max 0x%4.4x latency: 0x%4.4x Timeout: 0x%4.4x",
2897 min, max, latency, to_multiplier);
2898
2899 memset(&rsp, 0, sizeof(rsp));
2900
2901 err = l2cap_check_conn_param(min, max, latency, to_multiplier);
2902 if (err)
2903 rsp.result = cpu_to_le16(L2CAP_CONN_PARAM_REJECTED);
2904 else
2905 rsp.result = cpu_to_le16(L2CAP_CONN_PARAM_ACCEPTED);
2906
2907 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_PARAM_UPDATE_RSP,
2908 sizeof(rsp), &rsp);
2909
2910 if (!err)
2911 hci_le_conn_update(hcon, min, max, latency, to_multiplier);
2912
2913 return 0;
2914 }
2915
2916 static inline int l2cap_bredr_sig_cmd(struct l2cap_conn *conn,
2917 struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data)
2918 {
2919 int err = 0;
2920
2921 switch (cmd->code) {
2922 case L2CAP_COMMAND_REJ:
2923 l2cap_command_rej(conn, cmd, data);
2924 break;
2925
2926 case L2CAP_CONN_REQ:
2927 err = l2cap_connect_req(conn, cmd, data);
2928 break;
2929
2930 case L2CAP_CONN_RSP:
2931 err = l2cap_connect_rsp(conn, cmd, data);
2932 break;
2933
2934 case L2CAP_CONF_REQ:
2935 err = l2cap_config_req(conn, cmd, cmd_len, data);
2936 break;
2937
2938 case L2CAP_CONF_RSP:
2939 err = l2cap_config_rsp(conn, cmd, data);
2940 break;
2941
2942 case L2CAP_DISCONN_REQ:
2943 err = l2cap_disconnect_req(conn, cmd, data);
2944 break;
2945
2946 case L2CAP_DISCONN_RSP:
2947 err = l2cap_disconnect_rsp(conn, cmd, data);
2948 break;
2949
2950 case L2CAP_ECHO_REQ:
2951 l2cap_send_cmd(conn, cmd->ident, L2CAP_ECHO_RSP, cmd_len, data);
2952 break;
2953
2954 case L2CAP_ECHO_RSP:
2955 break;
2956
2957 case L2CAP_INFO_REQ:
2958 err = l2cap_information_req(conn, cmd, data);
2959 break;
2960
2961 case L2CAP_INFO_RSP:
2962 err = l2cap_information_rsp(conn, cmd, data);
2963 break;
2964
2965 default:
2966 BT_ERR("Unknown BR/EDR signaling command 0x%2.2x", cmd->code);
2967 err = -EINVAL;
2968 break;
2969 }
2970
2971 return err;
2972 }
2973
2974 static inline int l2cap_le_sig_cmd(struct l2cap_conn *conn,
2975 struct l2cap_cmd_hdr *cmd, u8 *data)
2976 {
2977 switch (cmd->code) {
2978 case L2CAP_COMMAND_REJ:
2979 return 0;
2980
2981 case L2CAP_CONN_PARAM_UPDATE_REQ:
2982 return l2cap_conn_param_update_req(conn, cmd, data);
2983
2984 case L2CAP_CONN_PARAM_UPDATE_RSP:
2985 return 0;
2986
2987 default:
2988 BT_ERR("Unknown LE signaling command 0x%2.2x", cmd->code);
2989 return -EINVAL;
2990 }
2991 }
2992
2993 static inline void l2cap_sig_channel(struct l2cap_conn *conn,
2994 struct sk_buff *skb)
2995 {
2996 u8 *data = skb->data;
2997 int len = skb->len;
2998 struct l2cap_cmd_hdr cmd;
2999 int err;
3000
3001 l2cap_raw_recv(conn, skb);
3002
3003 while (len >= L2CAP_CMD_HDR_SIZE) {
3004 u16 cmd_len;
3005 memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE);
3006 data += L2CAP_CMD_HDR_SIZE;
3007 len -= L2CAP_CMD_HDR_SIZE;
3008
3009 cmd_len = le16_to_cpu(cmd.len);
3010
3011 BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, cmd.ident);
3012
3013 if (cmd_len > len || !cmd.ident) {
3014 BT_DBG("corrupted command");
3015 break;
3016 }
3017
3018 if (conn->hcon->type == LE_LINK)
3019 err = l2cap_le_sig_cmd(conn, &cmd, data);
3020 else
3021 err = l2cap_bredr_sig_cmd(conn, &cmd, cmd_len, data);
3022
3023 if (err) {
3024 struct l2cap_cmd_rej_unk rej;
3025
3026 BT_ERR("Wrong link type (%d)", err);
3027
3028 /* FIXME: Map err to a valid reason */
3029 rej.reason = cpu_to_le16(L2CAP_REJ_NOT_UNDERSTOOD);
3030 l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, sizeof(rej), &rej);
3031 }
3032
3033 data += cmd_len;
3034 len -= cmd_len;
3035 }
3036
3037 kfree_skb(skb);
3038 }
3039
3040 static int l2cap_check_fcs(struct l2cap_chan *chan, struct sk_buff *skb)
3041 {
3042 u16 our_fcs, rcv_fcs;
3043 int hdr_size = L2CAP_HDR_SIZE + 2;
3044
3045 if (chan->fcs == L2CAP_FCS_CRC16) {
3046 skb_trim(skb, skb->len - 2);
3047 rcv_fcs = get_unaligned_le16(skb->data + skb->len);
3048 our_fcs = crc16(0, skb->data - hdr_size, skb->len + hdr_size);
3049
3050 if (our_fcs != rcv_fcs)
3051 return -EBADMSG;
3052 }
3053 return 0;
3054 }
3055
3056 static inline void l2cap_send_i_or_rr_or_rnr(struct l2cap_chan *chan)
3057 {
3058 u16 control = 0;
3059
3060 chan->frames_sent = 0;
3061
3062 control |= chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
3063
3064 if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
3065 control |= L2CAP_SUPER_RCV_NOT_READY;
3066 l2cap_send_sframe(chan, control);
3067 set_bit(CONN_RNR_SENT, &chan->conn_state);
3068 }
3069
3070 if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state))
3071 l2cap_retransmit_frames(chan);
3072
3073 l2cap_ertm_send(chan);
3074
3075 if (!test_bit(CONN_LOCAL_BUSY, &chan->conn_state) &&
3076 chan->frames_sent == 0) {
3077 control |= L2CAP_SUPER_RCV_READY;
3078 l2cap_send_sframe(chan, control);
3079 }
3080 }
3081
3082 static int l2cap_add_to_srej_queue(struct l2cap_chan *chan, struct sk_buff *skb, u8 tx_seq, u8 sar)
3083 {
3084 struct sk_buff *next_skb;
3085 int tx_seq_offset, next_tx_seq_offset;
3086
3087 bt_cb(skb)->tx_seq = tx_seq;
3088 bt_cb(skb)->sar = sar;
3089
3090 next_skb = skb_peek(&chan->srej_q);
3091 if (!next_skb) {
3092 __skb_queue_tail(&chan->srej_q, skb);
3093 return 0;
3094 }
3095
3096 tx_seq_offset = (tx_seq - chan->buffer_seq) % 64;
3097 if (tx_seq_offset < 0)
3098 tx_seq_offset += 64;
3099
3100 do {
3101 if (bt_cb(next_skb)->tx_seq == tx_seq)
3102 return -EINVAL;
3103
3104 next_tx_seq_offset = (bt_cb(next_skb)->tx_seq -
3105 chan->buffer_seq) % 64;
3106 if (next_tx_seq_offset < 0)
3107 next_tx_seq_offset += 64;
3108
3109 if (next_tx_seq_offset > tx_seq_offset) {
3110 __skb_queue_before(&chan->srej_q, next_skb, skb);
3111 return 0;
3112 }
3113
3114 if (skb_queue_is_last(&chan->srej_q, next_skb))
3115 break;
3116
3117 } while ((next_skb = skb_queue_next(&chan->srej_q, next_skb)));
3118
3119 __skb_queue_tail(&chan->srej_q, skb);
3120
3121 return 0;
3122 }
3123
3124 static int l2cap_ertm_reassembly_sdu(struct l2cap_chan *chan, struct sk_buff *skb, u16 control)
3125 {
3126 struct sk_buff *_skb;
3127 int err;
3128
3129 switch (control & L2CAP_CTRL_SAR) {
3130 case L2CAP_SDU_UNSEGMENTED:
3131 if (test_bit(CONN_SAR_SDU, &chan->conn_state))
3132 goto drop;
3133
3134 return chan->ops->recv(chan->data, skb);
3135
3136 case L2CAP_SDU_START:
3137 if (test_bit(CONN_SAR_SDU, &chan->conn_state))
3138 goto drop;
3139
3140 chan->sdu_len = get_unaligned_le16(skb->data);
3141
3142 if (chan->sdu_len > chan->imtu)
3143 goto disconnect;
3144
3145 chan->sdu = bt_skb_alloc(chan->sdu_len, GFP_ATOMIC);
3146 if (!chan->sdu)
3147 return -ENOMEM;
3148
3149 /* pull sdu_len bytes only after alloc, because of Local Busy
3150 * condition we have to be sure that this will be executed
3151 * only once, i.e., when alloc does not fail */
3152 skb_pull(skb, 2);
3153
3154 memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
3155
3156 set_bit(CONN_SAR_SDU, &chan->conn_state);
3157 chan->partial_sdu_len = skb->len;
3158 break;
3159
3160 case L2CAP_SDU_CONTINUE:
3161 if (!test_bit(CONN_SAR_SDU, &chan->conn_state))
3162 goto disconnect;
3163
3164 if (!chan->sdu)
3165 goto disconnect;
3166
3167 chan->partial_sdu_len += skb->len;
3168 if (chan->partial_sdu_len > chan->sdu_len)
3169 goto drop;
3170
3171 memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
3172
3173 break;
3174
3175 case L2CAP_SDU_END:
3176 if (!test_bit(CONN_SAR_SDU, &chan->conn_state))
3177 goto disconnect;
3178
3179 if (!chan->sdu)
3180 goto disconnect;
3181
3182 chan->partial_sdu_len += skb->len;
3183
3184 if (chan->partial_sdu_len > chan->imtu)
3185 goto drop;
3186
3187 if (chan->partial_sdu_len != chan->sdu_len)
3188 goto drop;
3189
3190 memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
3191
3192 _skb = skb_clone(chan->sdu, GFP_ATOMIC);
3193 if (!_skb) {
3194 return -ENOMEM;
3195 }
3196
3197 err = chan->ops->recv(chan->data, _skb);
3198 if (err < 0) {
3199 kfree_skb(_skb);
3200 return err;
3201 }
3202
3203 clear_bit(CONN_SAR_SDU, &chan->conn_state);
3204
3205 kfree_skb(chan->sdu);
3206 break;
3207 }
3208
3209 kfree_skb(skb);
3210 return 0;
3211
3212 drop:
3213 kfree_skb(chan->sdu);
3214 chan->sdu = NULL;
3215
3216 disconnect:
3217 l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
3218 kfree_skb(skb);
3219 return 0;
3220 }
3221
3222 static void l2cap_ertm_enter_local_busy(struct l2cap_chan *chan)
3223 {
3224 u16 control;
3225
3226 BT_DBG("chan %p, Enter local busy", chan);
3227
3228 set_bit(CONN_LOCAL_BUSY, &chan->conn_state);
3229
3230 control = chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
3231 control |= L2CAP_SUPER_RCV_NOT_READY;
3232 l2cap_send_sframe(chan, control);
3233
3234 set_bit(CONN_RNR_SENT, &chan->conn_state);
3235
3236 __clear_ack_timer(chan);
3237 }
3238
3239 static void l2cap_ertm_exit_local_busy(struct l2cap_chan *chan)
3240 {
3241 u16 control;
3242
3243 if (!test_bit(CONN_RNR_SENT, &chan->conn_state))
3244 goto done;
3245
3246 control = chan->buffer_seq << L2CAP_CTRL_REQSEQ_SHIFT;
3247 control |= L2CAP_SUPER_RCV_READY | L2CAP_CTRL_POLL;
3248 l2cap_send_sframe(chan, control);
3249 chan->retry_count = 1;
3250
3251 __clear_retrans_timer(chan);
3252 __set_monitor_timer(chan);
3253
3254 set_bit(CONN_WAIT_F, &chan->conn_state);
3255
3256 done:
3257 clear_bit(CONN_LOCAL_BUSY, &chan->conn_state);
3258 clear_bit(CONN_RNR_SENT, &chan->conn_state);
3259
3260 BT_DBG("chan %p, Exit local busy", chan);
3261 }
3262
3263 void l2cap_chan_busy(struct l2cap_chan *chan, int busy)
3264 {
3265 if (chan->mode == L2CAP_MODE_ERTM) {
3266 if (busy)
3267 l2cap_ertm_enter_local_busy(chan);
3268 else
3269 l2cap_ertm_exit_local_busy(chan);
3270 }
3271 }
3272
3273 static int l2cap_streaming_reassembly_sdu(struct l2cap_chan *chan, struct sk_buff *skb, u16 control)
3274 {
3275 struct sk_buff *_skb;
3276 int err = -EINVAL;
3277
3278 /*
3279 * TODO: We have to notify the userland if some data is lost with the
3280 * Streaming Mode.
3281 */
3282
3283 switch (control & L2CAP_CTRL_SAR) {
3284 case L2CAP_SDU_UNSEGMENTED:
3285 if (test_bit(CONN_SAR_SDU, &chan->conn_state)) {
3286 kfree_skb(chan->sdu);
3287 break;
3288 }
3289
3290 err = chan->ops->recv(chan->data, skb);
3291 if (!err)
3292 return 0;
3293
3294 break;
3295
3296 case L2CAP_SDU_START:
3297 if (test_bit(CONN_SAR_SDU, &chan->conn_state)) {
3298 kfree_skb(chan->sdu);
3299 break;
3300 }
3301
3302 chan->sdu_len = get_unaligned_le16(skb->data);
3303 skb_pull(skb, 2);
3304
3305 if (chan->sdu_len > chan->imtu) {
3306 err = -EMSGSIZE;
3307 break;
3308 }
3309
3310 chan->sdu = bt_skb_alloc(chan->sdu_len, GFP_ATOMIC);
3311 if (!chan->sdu) {
3312 err = -ENOMEM;
3313 break;
3314 }
3315
3316 memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
3317
3318 set_bit(CONN_SAR_SDU, &chan->conn_state);
3319 chan->partial_sdu_len = skb->len;
3320 err = 0;
3321 break;
3322
3323 case L2CAP_SDU_CONTINUE:
3324 if (!test_bit(CONN_SAR_SDU, &chan->conn_state))
3325 break;
3326
3327 memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
3328
3329 chan->partial_sdu_len += skb->len;
3330 if (chan->partial_sdu_len > chan->sdu_len)
3331 kfree_skb(chan->sdu);
3332 else
3333 err = 0;
3334
3335 break;
3336
3337 case L2CAP_SDU_END:
3338 if (!test_bit(CONN_SAR_SDU, &chan->conn_state))
3339 break;
3340
3341 memcpy(skb_put(chan->sdu, skb->len), skb->data, skb->len);
3342
3343 clear_bit(CONN_SAR_SDU, &chan->conn_state);
3344 chan->partial_sdu_len += skb->len;
3345
3346 if (chan->partial_sdu_len > chan->imtu)
3347 goto drop;
3348
3349 if (chan->partial_sdu_len == chan->sdu_len) {
3350 _skb = skb_clone(chan->sdu, GFP_ATOMIC);
3351 err = chan->ops->recv(chan->data, _skb);
3352 if (err < 0)
3353 kfree_skb(_skb);
3354 }
3355 err = 0;
3356
3357 drop:
3358 kfree_skb(chan->sdu);
3359 break;
3360 }
3361
3362 kfree_skb(skb);
3363 return err;
3364 }
3365
3366 static void l2cap_check_srej_gap(struct l2cap_chan *chan, u8 tx_seq)
3367 {
3368 struct sk_buff *skb;
3369 u16 control;
3370
3371 while ((skb = skb_peek(&chan->srej_q)) &&
3372 !test_bit(CONN_LOCAL_BUSY, &chan->conn_state)) {
3373 int err;
3374
3375 if (bt_cb(skb)->tx_seq != tx_seq)
3376 break;
3377
3378 skb = skb_dequeue(&chan->srej_q);
3379 control = bt_cb(skb)->sar << L2CAP_CTRL_SAR_SHIFT;
3380 err = l2cap_ertm_reassembly_sdu(chan, skb, control);
3381
3382 if (err < 0) {
3383 l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
3384 break;
3385 }
3386
3387 chan->buffer_seq_srej =
3388 (chan->buffer_seq_srej + 1) % 64;
3389 tx_seq = (tx_seq + 1) % 64;
3390 }
3391 }
3392
3393 static void l2cap_resend_srejframe(struct l2cap_chan *chan, u8 tx_seq)
3394 {
3395 struct srej_list *l, *tmp;
3396 u16 control;
3397
3398 list_for_each_entry_safe(l, tmp, &chan->srej_l, list) {
3399 if (l->tx_seq == tx_seq) {
3400 list_del(&l->list);
3401 kfree(l);
3402 return;
3403 }
3404 control = L2CAP_SUPER_SELECT_REJECT;
3405 control |= l->tx_seq << L2CAP_CTRL_REQSEQ_SHIFT;
3406 l2cap_send_sframe(chan, control);
3407 list_del(&l->list);
3408 list_add_tail(&l->list, &chan->srej_l);
3409 }
3410 }
3411
3412 static void l2cap_send_srejframe(struct l2cap_chan *chan, u8 tx_seq)
3413 {
3414 struct srej_list *new;
3415 u16 control;
3416
3417 while (tx_seq != chan->expected_tx_seq) {
3418 control = L2CAP_SUPER_SELECT_REJECT;
3419 control |= chan->expected_tx_seq << L2CAP_CTRL_REQSEQ_SHIFT;
3420 l2cap_send_sframe(chan, control);
3421
3422 new = kzalloc(sizeof(struct srej_list), GFP_ATOMIC);
3423 new->tx_seq = chan->expected_tx_seq;
3424 chan->expected_tx_seq = (chan->expected_tx_seq + 1) % 64;
3425 list_add_tail(&new->list, &chan->srej_l);
3426 }
3427 chan->expected_tx_seq = (chan->expected_tx_seq + 1) % 64;
3428 }
3429
3430 static inline int l2cap_data_channel_iframe(struct l2cap_chan *chan, u16 rx_control, struct sk_buff *skb)
3431 {
3432 u8 tx_seq = __get_txseq(rx_control);
3433 u8 req_seq = __get_reqseq(rx_control);
3434 u8 sar = rx_control >> L2CAP_CTRL_SAR_SHIFT;
3435 int tx_seq_offset, expected_tx_seq_offset;
3436 int num_to_ack = (chan->tx_win/6) + 1;
3437 int err = 0;
3438
3439 BT_DBG("chan %p len %d tx_seq %d rx_control 0x%4.4x", chan, skb->len,
3440 tx_seq, rx_control);
3441
3442 if (L2CAP_CTRL_FINAL & rx_control &&
3443 test_bit(CONN_WAIT_F, &chan->conn_state)) {
3444 __clear_monitor_timer(chan);
3445 if (chan->unacked_frames > 0)
3446 __set_retrans_timer(chan);
3447 clear_bit(CONN_WAIT_F, &chan->conn_state);
3448 }
3449
3450 chan->expected_ack_seq = req_seq;
3451 l2cap_drop_acked_frames(chan);
3452
3453 tx_seq_offset = (tx_seq - chan->buffer_seq) % 64;
3454 if (tx_seq_offset < 0)
3455 tx_seq_offset += 64;
3456
3457 /* invalid tx_seq */
3458 if (tx_seq_offset >= chan->tx_win) {
3459 l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
3460 goto drop;
3461 }
3462
3463 if (test_bit(CONN_LOCAL_BUSY, &chan->conn_state))
3464 goto drop;
3465
3466 if (tx_seq == chan->expected_tx_seq)
3467 goto expected;
3468
3469 if (test_bit(CONN_SREJ_SENT, &chan->conn_state)) {
3470 struct srej_list *first;
3471
3472 first = list_first_entry(&chan->srej_l,
3473 struct srej_list, list);
3474 if (tx_seq == first->tx_seq) {
3475 l2cap_add_to_srej_queue(chan, skb, tx_seq, sar);
3476 l2cap_check_srej_gap(chan, tx_seq);
3477
3478 list_del(&first->list);
3479 kfree(first);
3480
3481 if (list_empty(&chan->srej_l)) {
3482 chan->buffer_seq = chan->buffer_seq_srej;
3483 clear_bit(CONN_SREJ_SENT, &chan->conn_state);
3484 l2cap_send_ack(chan);
3485 BT_DBG("chan %p, Exit SREJ_SENT", chan);
3486 }
3487 } else {
3488 struct srej_list *l;
3489
3490 /* duplicated tx_seq */
3491 if (l2cap_add_to_srej_queue(chan, skb, tx_seq, sar) < 0)
3492 goto drop;
3493
3494 list_for_each_entry(l, &chan->srej_l, list) {
3495 if (l->tx_seq == tx_seq) {
3496 l2cap_resend_srejframe(chan, tx_seq);
3497 return 0;
3498 }
3499 }
3500 l2cap_send_srejframe(chan, tx_seq);
3501 }
3502 } else {
3503 expected_tx_seq_offset =
3504 (chan->expected_tx_seq - chan->buffer_seq) % 64;
3505 if (expected_tx_seq_offset < 0)
3506 expected_tx_seq_offset += 64;
3507
3508 /* duplicated tx_seq */
3509 if (tx_seq_offset < expected_tx_seq_offset)
3510 goto drop;
3511
3512 set_bit(CONN_SREJ_SENT, &chan->conn_state);
3513
3514 BT_DBG("chan %p, Enter SREJ", chan);
3515
3516 INIT_LIST_HEAD(&chan->srej_l);
3517 chan->buffer_seq_srej = chan->buffer_seq;
3518
3519 __skb_queue_head_init(&chan->srej_q);
3520 l2cap_add_to_srej_queue(chan, skb, tx_seq, sar);
3521
3522 set_bit(CONN_SEND_PBIT, &chan->conn_state);
3523
3524 l2cap_send_srejframe(chan, tx_seq);
3525
3526 __clear_ack_timer(chan);
3527 }
3528 return 0;
3529
3530 expected:
3531 chan->expected_tx_seq = (chan->expected_tx_seq + 1) % 64;
3532
3533 if (test_bit(CONN_SREJ_SENT, &chan->conn_state)) {
3534 bt_cb(skb)->tx_seq = tx_seq;
3535 bt_cb(skb)->sar = sar;
3536 __skb_queue_tail(&chan->srej_q, skb);
3537 return 0;
3538 }
3539
3540 err = l2cap_ertm_reassembly_sdu(chan, skb, rx_control);
3541 chan->buffer_seq = (chan->buffer_seq + 1) % 64;
3542 if (err < 0) {
3543 l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
3544 return err;
3545 }
3546
3547 if (rx_control & L2CAP_CTRL_FINAL) {
3548 if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state))
3549 l2cap_retransmit_frames(chan);
3550 }
3551
3552 __set_ack_timer(chan);
3553
3554 chan->num_acked = (chan->num_acked + 1) % num_to_ack;
3555 if (chan->num_acked == num_to_ack - 1)
3556 l2cap_send_ack(chan);
3557
3558 return 0;
3559
3560 drop:
3561 kfree_skb(skb);
3562 return 0;
3563 }
3564
3565 static inline void l2cap_data_channel_rrframe(struct l2cap_chan *chan, u16 rx_control)
3566 {
3567 BT_DBG("chan %p, req_seq %d ctrl 0x%4.4x", chan, __get_reqseq(rx_control),
3568 rx_control);
3569
3570 chan->expected_ack_seq = __get_reqseq(rx_control);
3571 l2cap_drop_acked_frames(chan);
3572
3573 if (rx_control & L2CAP_CTRL_POLL) {
3574 set_bit(CONN_SEND_FBIT, &chan->conn_state);
3575 if (test_bit(CONN_SREJ_SENT, &chan->conn_state)) {
3576 if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state) &&
3577 (chan->unacked_frames > 0))
3578 __set_retrans_timer(chan);
3579
3580 clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
3581 l2cap_send_srejtail(chan);
3582 } else {
3583 l2cap_send_i_or_rr_or_rnr(chan);
3584 }
3585
3586 } else if (rx_control & L2CAP_CTRL_FINAL) {
3587 clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
3588
3589 if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state))
3590 l2cap_retransmit_frames(chan);
3591
3592 } else {
3593 if (test_bit(CONN_REMOTE_BUSY, &chan->conn_state) &&
3594 (chan->unacked_frames > 0))
3595 __set_retrans_timer(chan);
3596
3597 clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
3598 if (test_bit(CONN_SREJ_SENT, &chan->conn_state))
3599 l2cap_send_ack(chan);
3600 else
3601 l2cap_ertm_send(chan);
3602 }
3603 }
3604
3605 static inline void l2cap_data_channel_rejframe(struct l2cap_chan *chan, u16 rx_control)
3606 {
3607 u8 tx_seq = __get_reqseq(rx_control);
3608
3609 BT_DBG("chan %p, req_seq %d ctrl 0x%4.4x", chan, tx_seq, rx_control);
3610
3611 clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
3612
3613 chan->expected_ack_seq = tx_seq;
3614 l2cap_drop_acked_frames(chan);
3615
3616 if (rx_control & L2CAP_CTRL_FINAL) {
3617 if (!test_and_clear_bit(CONN_REJ_ACT, &chan->conn_state))
3618 l2cap_retransmit_frames(chan);
3619 } else {
3620 l2cap_retransmit_frames(chan);
3621
3622 if (test_bit(CONN_WAIT_F, &chan->conn_state))
3623 set_bit(CONN_REJ_ACT, &chan->conn_state);
3624 }
3625 }
3626 static inline void l2cap_data_channel_srejframe(struct l2cap_chan *chan, u16 rx_control)
3627 {
3628 u8 tx_seq = __get_reqseq(rx_control);
3629
3630 BT_DBG("chan %p, req_seq %d ctrl 0x%4.4x", chan, tx_seq, rx_control);
3631
3632 clear_bit(CONN_REMOTE_BUSY, &chan->conn_state);
3633
3634 if (rx_control & L2CAP_CTRL_POLL) {
3635 chan->expected_ack_seq = tx_seq;
3636 l2cap_drop_acked_frames(chan);
3637
3638 set_bit(CONN_SEND_FBIT, &chan->conn_state);
3639 l2cap_retransmit_one_frame(chan, tx_seq);
3640
3641 l2cap_ertm_send(chan);
3642
3643 if (test_bit(CONN_WAIT_F, &chan->conn_state)) {
3644 chan->srej_save_reqseq = tx_seq;
3645 set_bit(CONN_SREJ_ACT, &chan->conn_state);
3646 }
3647 } else if (rx_control & L2CAP_CTRL_FINAL) {
3648 if (test_bit(CONN_SREJ_ACT, &chan->conn_state) &&
3649 chan->srej_save_reqseq == tx_seq)
3650 clear_bit(CONN_SREJ_ACT, &chan->conn_state);
3651 else
3652 l2cap_retransmit_one_frame(chan, tx_seq);
3653 } else {
3654 l2cap_retransmit_one_frame(chan, tx_seq);
3655 if (test_bit(CONN_WAIT_F, &chan->conn_state)) {
3656 chan->srej_save_reqseq = tx_seq;
3657 set_bit(CONN_SREJ_ACT, &chan->conn_state);
3658 }
3659 }
3660 }
3661
3662 static inline void l2cap_data_channel_rnrframe(struct l2cap_chan *chan, u16 rx_control)
3663 {
3664 u8 tx_seq = __get_reqseq(rx_control);
3665
3666 BT_DBG("chan %p, req_seq %d ctrl 0x%4.4x", chan, tx_seq, rx_control);
3667
3668 set_bit(CONN_REMOTE_BUSY, &chan->conn_state);
3669 chan->expected_ack_seq = tx_seq;
3670 l2cap_drop_acked_frames(chan);
3671
3672 if (rx_control & L2CAP_CTRL_POLL)
3673 set_bit(CONN_SEND_FBIT, &chan->conn_state);
3674
3675 if (!test_bit(CONN_SREJ_SENT, &chan->conn_state)) {
3676 __clear_retrans_timer(chan);
3677 if (rx_control & L2CAP_CTRL_POLL)
3678 l2cap_send_rr_or_rnr(chan, L2CAP_CTRL_FINAL);
3679 return;
3680 }
3681
3682 if (rx_control & L2CAP_CTRL_POLL)
3683 l2cap_send_srejtail(chan);
3684 else
3685 l2cap_send_sframe(chan, L2CAP_SUPER_RCV_READY);
3686 }
3687
3688 static inline int l2cap_data_channel_sframe(struct l2cap_chan *chan, u16 rx_control, struct sk_buff *skb)
3689 {
3690 BT_DBG("chan %p rx_control 0x%4.4x len %d", chan, rx_control, skb->len);
3691
3692 if (L2CAP_CTRL_FINAL & rx_control &&
3693 test_bit(CONN_WAIT_F, &chan->conn_state)) {
3694 __clear_monitor_timer(chan);
3695 if (chan->unacked_frames > 0)
3696 __set_retrans_timer(chan);
3697 clear_bit(CONN_WAIT_F, &chan->conn_state);
3698 }
3699
3700 switch (rx_control & L2CAP_CTRL_SUPERVISE) {
3701 case L2CAP_SUPER_RCV_READY:
3702 l2cap_data_channel_rrframe(chan, rx_control);
3703 break;
3704
3705 case L2CAP_SUPER_REJECT:
3706 l2cap_data_channel_rejframe(chan, rx_control);
3707 break;
3708
3709 case L2CAP_SUPER_SELECT_REJECT:
3710 l2cap_data_channel_srejframe(chan, rx_control);
3711 break;
3712
3713 case L2CAP_SUPER_RCV_NOT_READY:
3714 l2cap_data_channel_rnrframe(chan, rx_control);
3715 break;
3716 }
3717
3718 kfree_skb(skb);
3719 return 0;
3720 }
3721
3722 static int l2cap_ertm_data_rcv(struct sock *sk, struct sk_buff *skb)
3723 {
3724 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
3725 u16 control;
3726 u8 req_seq;
3727 int len, next_tx_seq_offset, req_seq_offset;
3728
3729 control = get_unaligned_le16(skb->data);
3730 skb_pull(skb, 2);
3731 len = skb->len;
3732
3733 /*
3734 * We can just drop the corrupted I-frame here.
3735 * Receiver will miss it and start proper recovery
3736 * procedures and ask retransmission.
3737 */
3738 if (l2cap_check_fcs(chan, skb))
3739 goto drop;
3740
3741 if (__is_sar_start(control) && __is_iframe(control))
3742 len -= 2;
3743
3744 if (chan->fcs == L2CAP_FCS_CRC16)
3745 len -= 2;
3746
3747 if (len > chan->mps) {
3748 l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
3749 goto drop;
3750 }
3751
3752 req_seq = __get_reqseq(control);
3753 req_seq_offset = (req_seq - chan->expected_ack_seq) % 64;
3754 if (req_seq_offset < 0)
3755 req_seq_offset += 64;
3756
3757 next_tx_seq_offset =
3758 (chan->next_tx_seq - chan->expected_ack_seq) % 64;
3759 if (next_tx_seq_offset < 0)
3760 next_tx_seq_offset += 64;
3761
3762 /* check for invalid req-seq */
3763 if (req_seq_offset > next_tx_seq_offset) {
3764 l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
3765 goto drop;
3766 }
3767
3768 if (__is_iframe(control)) {
3769 if (len < 0) {
3770 l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
3771 goto drop;
3772 }
3773
3774 l2cap_data_channel_iframe(chan, control, skb);
3775 } else {
3776 if (len != 0) {
3777 BT_ERR("%d", len);
3778 l2cap_send_disconn_req(chan->conn, chan, ECONNRESET);
3779 goto drop;
3780 }
3781
3782 l2cap_data_channel_sframe(chan, control, skb);
3783 }
3784
3785 return 0;
3786
3787 drop:
3788 kfree_skb(skb);
3789 return 0;
3790 }
3791
3792 static inline int l2cap_data_channel(struct l2cap_conn *conn, u16 cid, struct sk_buff *skb)
3793 {
3794 struct l2cap_chan *chan;
3795 struct sock *sk = NULL;
3796 u16 control;
3797 u8 tx_seq;
3798 int len;
3799
3800 chan = l2cap_get_chan_by_scid(conn, cid);
3801 if (!chan) {
3802 BT_DBG("unknown cid 0x%4.4x", cid);
3803 goto drop;
3804 }
3805
3806 sk = chan->sk;
3807
3808 BT_DBG("chan %p, len %d", chan, skb->len);
3809
3810 if (chan->state != BT_CONNECTED)
3811 goto drop;
3812
3813 switch (chan->mode) {
3814 case L2CAP_MODE_BASIC:
3815 /* If socket recv buffers overflows we drop data here
3816 * which is *bad* because L2CAP has to be reliable.
3817 * But we don't have any other choice. L2CAP doesn't
3818 * provide flow control mechanism. */
3819
3820 if (chan->imtu < skb->len)
3821 goto drop;
3822
3823 if (!chan->ops->recv(chan->data, skb))
3824 goto done;
3825 break;
3826
3827 case L2CAP_MODE_ERTM:
3828 if (!sock_owned_by_user(sk)) {
3829 l2cap_ertm_data_rcv(sk, skb);
3830 } else {
3831 if (sk_add_backlog(sk, skb))
3832 goto drop;
3833 }
3834
3835 goto done;
3836
3837 case L2CAP_MODE_STREAMING:
3838 control = get_unaligned_le16(skb->data);
3839 skb_pull(skb, 2);
3840 len = skb->len;
3841
3842 if (l2cap_check_fcs(chan, skb))
3843 goto drop;
3844
3845 if (__is_sar_start(control))
3846 len -= 2;
3847
3848 if (chan->fcs == L2CAP_FCS_CRC16)
3849 len -= 2;
3850
3851 if (len > chan->mps || len < 0 || __is_sframe(control))
3852 goto drop;
3853
3854 tx_seq = __get_txseq(control);
3855
3856 if (chan->expected_tx_seq == tx_seq)
3857 chan->expected_tx_seq = (chan->expected_tx_seq + 1) % 64;
3858 else
3859 chan->expected_tx_seq = (tx_seq + 1) % 64;
3860
3861 l2cap_streaming_reassembly_sdu(chan, skb, control);
3862
3863 goto done;
3864
3865 default:
3866 BT_DBG("chan %p: bad mode 0x%2.2x", chan, chan->mode);
3867 break;
3868 }
3869
3870 drop:
3871 kfree_skb(skb);
3872
3873 done:
3874 if (sk)
3875 bh_unlock_sock(sk);
3876
3877 return 0;
3878 }
3879
3880 static inline int l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, struct sk_buff *skb)
3881 {
3882 struct sock *sk = NULL;
3883 struct l2cap_chan *chan;
3884
3885 chan = l2cap_global_chan_by_psm(0, psm, conn->src);
3886 if (!chan)
3887 goto drop;
3888
3889 sk = chan->sk;
3890
3891 bh_lock_sock(sk);
3892
3893 BT_DBG("sk %p, len %d", sk, skb->len);
3894
3895 if (chan->state != BT_BOUND && chan->state != BT_CONNECTED)
3896 goto drop;
3897
3898 if (chan->imtu < skb->len)
3899 goto drop;
3900
3901 if (!chan->ops->recv(chan->data, skb))
3902 goto done;
3903
3904 drop:
3905 kfree_skb(skb);
3906
3907 done:
3908 if (sk)
3909 bh_unlock_sock(sk);
3910 return 0;
3911 }
3912
3913 static inline int l2cap_att_channel(struct l2cap_conn *conn, __le16 cid, struct sk_buff *skb)
3914 {
3915 struct sock *sk = NULL;
3916 struct l2cap_chan *chan;
3917
3918 chan = l2cap_global_chan_by_scid(0, cid, conn->src);
3919 if (!chan)
3920 goto drop;
3921
3922 sk = chan->sk;
3923
3924 bh_lock_sock(sk);
3925
3926 BT_DBG("sk %p, len %d", sk, skb->len);
3927
3928 if (chan->state != BT_BOUND && chan->state != BT_CONNECTED)
3929 goto drop;
3930
3931 if (chan->imtu < skb->len)
3932 goto drop;
3933
3934 if (!chan->ops->recv(chan->data, skb))
3935 goto done;
3936
3937 drop:
3938 kfree_skb(skb);
3939
3940 done:
3941 if (sk)
3942 bh_unlock_sock(sk);
3943 return 0;
3944 }
3945
3946 static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb)
3947 {
3948 struct l2cap_hdr *lh = (void *) skb->data;
3949 u16 cid, len;
3950 __le16 psm;
3951
3952 skb_pull(skb, L2CAP_HDR_SIZE);
3953 cid = __le16_to_cpu(lh->cid);
3954 len = __le16_to_cpu(lh->len);
3955
3956 if (len != skb->len) {
3957 kfree_skb(skb);
3958 return;
3959 }
3960
3961 BT_DBG("len %d, cid 0x%4.4x", len, cid);
3962
3963 switch (cid) {
3964 case L2CAP_CID_LE_SIGNALING:
3965 case L2CAP_CID_SIGNALING:
3966 l2cap_sig_channel(conn, skb);
3967 break;
3968
3969 case L2CAP_CID_CONN_LESS:
3970 psm = get_unaligned_le16(skb->data);
3971 skb_pull(skb, 2);
3972 l2cap_conless_channel(conn, psm, skb);
3973 break;
3974
3975 case L2CAP_CID_LE_DATA:
3976 l2cap_att_channel(conn, cid, skb);
3977 break;
3978
3979 case L2CAP_CID_SMP:
3980 if (smp_sig_channel(conn, skb))
3981 l2cap_conn_del(conn->hcon, EACCES);
3982 break;
3983
3984 default:
3985 l2cap_data_channel(conn, cid, skb);
3986 break;
3987 }
3988 }
3989
3990 /* ---- L2CAP interface with lower layer (HCI) ---- */
3991
3992 static int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
3993 {
3994 int exact = 0, lm1 = 0, lm2 = 0;
3995 struct l2cap_chan *c;
3996
3997 if (type != ACL_LINK)
3998 return -EINVAL;
3999
4000 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
4001
4002 /* Find listening sockets and check their link_mode */
4003 read_lock(&chan_list_lock);
4004 list_for_each_entry(c, &chan_list, global_l) {
4005 struct sock *sk = c->sk;
4006
4007 if (c->state != BT_LISTEN)
4008 continue;
4009
4010 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) {
4011 lm1 |= HCI_LM_ACCEPT;
4012 if (c->role_switch)
4013 lm1 |= HCI_LM_MASTER;
4014 exact++;
4015 } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY)) {
4016 lm2 |= HCI_LM_ACCEPT;
4017 if (c->role_switch)
4018 lm2 |= HCI_LM_MASTER;
4019 }
4020 }
4021 read_unlock(&chan_list_lock);
4022
4023 return exact ? lm1 : lm2;
4024 }
4025
4026 static int l2cap_connect_cfm(struct hci_conn *hcon, u8 status)
4027 {
4028 struct l2cap_conn *conn;
4029
4030 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
4031
4032 if (!(hcon->type == ACL_LINK || hcon->type == LE_LINK))
4033 return -EINVAL;
4034
4035 if (!status) {
4036 conn = l2cap_conn_add(hcon, status);
4037 if (conn)
4038 l2cap_conn_ready(conn);
4039 } else
4040 l2cap_conn_del(hcon, bt_to_errno(status));
4041
4042 return 0;
4043 }
4044
4045 static int l2cap_disconn_ind(struct hci_conn *hcon)
4046 {
4047 struct l2cap_conn *conn = hcon->l2cap_data;
4048
4049 BT_DBG("hcon %p", hcon);
4050
4051 if ((hcon->type != ACL_LINK && hcon->type != LE_LINK) || !conn)
4052 return 0x13;
4053
4054 return conn->disc_reason;
4055 }
4056
4057 static int l2cap_disconn_cfm(struct hci_conn *hcon, u8 reason)
4058 {
4059 BT_DBG("hcon %p reason %d", hcon, reason);
4060
4061 if (!(hcon->type == ACL_LINK || hcon->type == LE_LINK))
4062 return -EINVAL;
4063
4064 l2cap_conn_del(hcon, bt_to_errno(reason));
4065
4066 return 0;
4067 }
4068
4069 static inline void l2cap_check_encryption(struct l2cap_chan *chan, u8 encrypt)
4070 {
4071 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED)
4072 return;
4073
4074 if (encrypt == 0x00) {
4075 if (chan->sec_level == BT_SECURITY_MEDIUM) {
4076 __clear_chan_timer(chan);
4077 __set_chan_timer(chan, HZ * 5);
4078 } else if (chan->sec_level == BT_SECURITY_HIGH)
4079 l2cap_chan_close(chan, ECONNREFUSED);
4080 } else {
4081 if (chan->sec_level == BT_SECURITY_MEDIUM)
4082 __clear_chan_timer(chan);
4083 }
4084 }
4085
4086 static int l2cap_security_cfm(struct hci_conn *hcon, u8 status, u8 encrypt)
4087 {
4088 struct l2cap_conn *conn = hcon->l2cap_data;
4089 struct l2cap_chan *chan;
4090
4091 if (!conn)
4092 return 0;
4093
4094 BT_DBG("conn %p", conn);
4095
4096 read_lock(&conn->chan_lock);
4097
4098 list_for_each_entry(chan, &conn->chan_l, list) {
4099 struct sock *sk = chan->sk;
4100
4101 bh_lock_sock(sk);
4102
4103 BT_DBG("chan->scid %d", chan->scid);
4104
4105 if (chan->scid == L2CAP_CID_LE_DATA) {
4106 if (!status && encrypt) {
4107 chan->sec_level = hcon->sec_level;
4108 del_timer(&conn->security_timer);
4109 l2cap_chan_ready(sk);
4110 smp_distribute_keys(conn, 0);
4111 }
4112
4113 bh_unlock_sock(sk);
4114 continue;
4115 }
4116
4117 if (test_bit(CONF_CONNECT_PEND, &chan->conf_state)) {
4118 bh_unlock_sock(sk);
4119 continue;
4120 }
4121
4122 if (!status && (chan->state == BT_CONNECTED ||
4123 chan->state == BT_CONFIG)) {
4124 l2cap_check_encryption(chan, encrypt);
4125 bh_unlock_sock(sk);
4126 continue;
4127 }
4128
4129 if (chan->state == BT_CONNECT) {
4130 if (!status) {
4131 struct l2cap_conn_req req;
4132 req.scid = cpu_to_le16(chan->scid);
4133 req.psm = chan->psm;
4134
4135 chan->ident = l2cap_get_ident(conn);
4136 set_bit(CONF_CONNECT_PEND, &chan->conf_state);
4137
4138 l2cap_send_cmd(conn, chan->ident,
4139 L2CAP_CONN_REQ, sizeof(req), &req);
4140 } else {
4141 __clear_chan_timer(chan);
4142 __set_chan_timer(chan, HZ / 10);
4143 }
4144 } else if (chan->state == BT_CONNECT2) {
4145 struct l2cap_conn_rsp rsp;
4146 __u16 res, stat;
4147
4148 if (!status) {
4149 if (bt_sk(sk)->defer_setup) {
4150 struct sock *parent = bt_sk(sk)->parent;
4151 res = L2CAP_CR_PEND;
4152 stat = L2CAP_CS_AUTHOR_PEND;
4153 if (parent)
4154 parent->sk_data_ready(parent, 0);
4155 } else {
4156 l2cap_state_change(chan, BT_CONFIG);
4157 res = L2CAP_CR_SUCCESS;
4158 stat = L2CAP_CS_NO_INFO;
4159 }
4160 } else {
4161 l2cap_state_change(chan, BT_DISCONN);
4162 __set_chan_timer(chan, HZ / 10);
4163 res = L2CAP_CR_SEC_BLOCK;
4164 stat = L2CAP_CS_NO_INFO;
4165 }
4166
4167 rsp.scid = cpu_to_le16(chan->dcid);
4168 rsp.dcid = cpu_to_le16(chan->scid);
4169 rsp.result = cpu_to_le16(res);
4170 rsp.status = cpu_to_le16(stat);
4171 l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
4172 sizeof(rsp), &rsp);
4173 }
4174
4175 bh_unlock_sock(sk);
4176 }
4177
4178 read_unlock(&conn->chan_lock);
4179
4180 return 0;
4181 }
4182
4183 static int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags)
4184 {
4185 struct l2cap_conn *conn = hcon->l2cap_data;
4186
4187 if (!conn)
4188 conn = l2cap_conn_add(hcon, 0);
4189
4190 if (!conn)
4191 goto drop;
4192
4193 BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags);
4194
4195 if (!(flags & ACL_CONT)) {
4196 struct l2cap_hdr *hdr;
4197 struct l2cap_chan *chan;
4198 u16 cid;
4199 int len;
4200
4201 if (conn->rx_len) {
4202 BT_ERR("Unexpected start frame (len %d)", skb->len);
4203 kfree_skb(conn->rx_skb);
4204 conn->rx_skb = NULL;
4205 conn->rx_len = 0;
4206 l2cap_conn_unreliable(conn, ECOMM);
4207 }
4208
4209 /* Start fragment always begin with Basic L2CAP header */
4210 if (skb->len < L2CAP_HDR_SIZE) {
4211 BT_ERR("Frame is too short (len %d)", skb->len);
4212 l2cap_conn_unreliable(conn, ECOMM);
4213 goto drop;
4214 }
4215
4216 hdr = (struct l2cap_hdr *) skb->data;
4217 len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE;
4218 cid = __le16_to_cpu(hdr->cid);
4219
4220 if (len == skb->len) {
4221 /* Complete frame received */
4222 l2cap_recv_frame(conn, skb);
4223 return 0;
4224 }
4225
4226 BT_DBG("Start: total len %d, frag len %d", len, skb->len);
4227
4228 if (skb->len > len) {
4229 BT_ERR("Frame is too long (len %d, expected len %d)",
4230 skb->len, len);
4231 l2cap_conn_unreliable(conn, ECOMM);
4232 goto drop;
4233 }
4234
4235 chan = l2cap_get_chan_by_scid(conn, cid);
4236
4237 if (chan && chan->sk) {
4238 struct sock *sk = chan->sk;
4239
4240 if (chan->imtu < len - L2CAP_HDR_SIZE) {
4241 BT_ERR("Frame exceeding recv MTU (len %d, "
4242 "MTU %d)", len,
4243 chan->imtu);
4244 bh_unlock_sock(sk);
4245 l2cap_conn_unreliable(conn, ECOMM);
4246 goto drop;
4247 }
4248 bh_unlock_sock(sk);
4249 }
4250
4251 /* Allocate skb for the complete frame (with header) */
4252 conn->rx_skb = bt_skb_alloc(len, GFP_ATOMIC);
4253 if (!conn->rx_skb)
4254 goto drop;
4255
4256 skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
4257 skb->len);
4258 conn->rx_len = len - skb->len;
4259 } else {
4260 BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len);
4261
4262 if (!conn->rx_len) {
4263 BT_ERR("Unexpected continuation frame (len %d)", skb->len);
4264 l2cap_conn_unreliable(conn, ECOMM);
4265 goto drop;
4266 }
4267
4268 if (skb->len > conn->rx_len) {
4269 BT_ERR("Fragment is too long (len %d, expected %d)",
4270 skb->len, conn->rx_len);
4271 kfree_skb(conn->rx_skb);
4272 conn->rx_skb = NULL;
4273 conn->rx_len = 0;
4274 l2cap_conn_unreliable(conn, ECOMM);
4275 goto drop;
4276 }
4277
4278 skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
4279 skb->len);
4280 conn->rx_len -= skb->len;
4281
4282 if (!conn->rx_len) {
4283 /* Complete frame received */
4284 l2cap_recv_frame(conn, conn->rx_skb);
4285 conn->rx_skb = NULL;
4286 }
4287 }
4288
4289 drop:
4290 kfree_skb(skb);
4291 return 0;
4292 }
4293
4294 static int l2cap_debugfs_show(struct seq_file *f, void *p)
4295 {
4296 struct l2cap_chan *c;
4297
4298 read_lock_bh(&chan_list_lock);
4299
4300 list_for_each_entry(c, &chan_list, global_l) {
4301 struct sock *sk = c->sk;
4302
4303 seq_printf(f, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d %d %d\n",
4304 batostr(&bt_sk(sk)->src),
4305 batostr(&bt_sk(sk)->dst),
4306 c->state, __le16_to_cpu(c->psm),
4307 c->scid, c->dcid, c->imtu, c->omtu,
4308 c->sec_level, c->mode);
4309 }
4310
4311 read_unlock_bh(&chan_list_lock);
4312
4313 return 0;
4314 }
4315
4316 static int l2cap_debugfs_open(struct inode *inode, struct file *file)
4317 {
4318 return single_open(file, l2cap_debugfs_show, inode->i_private);
4319 }
4320
4321 static const struct file_operations l2cap_debugfs_fops = {
4322 .open = l2cap_debugfs_open,
4323 .read = seq_read,
4324 .llseek = seq_lseek,
4325 .release = single_release,
4326 };
4327
4328 static struct dentry *l2cap_debugfs;
4329
4330 static struct hci_proto l2cap_hci_proto = {
4331 .name = "L2CAP",
4332 .id = HCI_PROTO_L2CAP,
4333 .connect_ind = l2cap_connect_ind,
4334 .connect_cfm = l2cap_connect_cfm,
4335 .disconn_ind = l2cap_disconn_ind,
4336 .disconn_cfm = l2cap_disconn_cfm,
4337 .security_cfm = l2cap_security_cfm,
4338 .recv_acldata = l2cap_recv_acldata
4339 };
4340
4341 int __init l2cap_init(void)
4342 {
4343 int err;
4344
4345 err = l2cap_init_sockets();
4346 if (err < 0)
4347 return err;
4348
4349 err = hci_register_proto(&l2cap_hci_proto);
4350 if (err < 0) {
4351 BT_ERR("L2CAP protocol registration failed");
4352 bt_sock_unregister(BTPROTO_L2CAP);
4353 goto error;
4354 }
4355
4356 if (bt_debugfs) {
4357 l2cap_debugfs = debugfs_create_file("l2cap", 0444,
4358 bt_debugfs, NULL, &l2cap_debugfs_fops);
4359 if (!l2cap_debugfs)
4360 BT_ERR("Failed to create L2CAP debug file");
4361 }
4362
4363 return 0;
4364
4365 error:
4366 l2cap_cleanup_sockets();
4367 return err;
4368 }
4369
4370 void l2cap_exit(void)
4371 {
4372 debugfs_remove(l2cap_debugfs);
4373
4374 if (hci_unregister_proto(&l2cap_hci_proto) < 0)
4375 BT_ERR("L2CAP protocol unregistration failed");
4376
4377 l2cap_cleanup_sockets();
4378 }
4379
4380 module_param(disable_ertm, bool, 0644);
4381 MODULE_PARM_DESC(disable_ertm, "Disable enhanced retransmission mode");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree