?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added !vmlinux.lds.h to .gitignore because it would otherwise be ignored.
[jz_linux_2.6.24.3.git] / net / bluetooth / l2cap.c
blob477e052b17b5d57bdbb820f9b5b98252b13f17b9
1 /*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation;
10
11 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22 SOFTWARE IS DISCLAIMED.
23 */
24
25 /* Bluetooth L2CAP core and sockets. */
26
27 #include <linux/module.h>
28
29 #include <linux/types.h>
30 #include <linux/capability.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/sched.h>
34 #include <linux/slab.h>
35 #include <linux/poll.h>
36 #include <linux/fcntl.h>
37 #include <linux/init.h>
38 #include <linux/interrupt.h>
39 #include <linux/socket.h>
40 #include <linux/skbuff.h>
41 #include <linux/list.h>
42 #include <linux/device.h>
43 #include <net/sock.h>
44
45 #include <asm/system.h>
46 #include <asm/uaccess.h>
47 #include <asm/unaligned.h>
48
49 #include <net/bluetooth/bluetooth.h>
50 #include <net/bluetooth/hci_core.h>
51 #include <net/bluetooth/l2cap.h>
52
53 #ifndef CONFIG_BT_L2CAP_DEBUG
54 #undef BT_DBG
55 #define BT_DBG(D...)
56 #endif
57
58 #define VERSION "2.9"
59
60 static u32 l2cap_feat_mask = 0x0000;
61
62 static const struct proto_ops l2cap_sock_ops;
63
64 static struct bt_sock_list l2cap_sk_list = {
65 .lock = RW_LOCK_UNLOCKED
66 };
67
68 static void __l2cap_sock_close(struct sock *sk, int reason);
69 static void l2cap_sock_close(struct sock *sk);
70 static void l2cap_sock_kill(struct sock *sk);
71
72 static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
73 u8 code, u8 ident, u16 dlen, void *data);
74
75 /* ---- L2CAP timers ---- */
76 static void l2cap_sock_timeout(unsigned long arg)
77 {
78 struct sock *sk = (struct sock *) arg;
79
80 BT_DBG("sock %p state %d", sk, sk->sk_state);
81
82 bh_lock_sock(sk);
83 __l2cap_sock_close(sk, ETIMEDOUT);
84 bh_unlock_sock(sk);
85
86 l2cap_sock_kill(sk);
87 sock_put(sk);
88 }
89
90 static void l2cap_sock_set_timer(struct sock *sk, long timeout)
91 {
92 BT_DBG("sk %p state %d timeout %ld", sk, sk->sk_state, timeout);
93 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
94 }
95
96 static void l2cap_sock_clear_timer(struct sock *sk)
97 {
98 BT_DBG("sock %p state %d", sk, sk->sk_state);
99 sk_stop_timer(sk, &sk->sk_timer);
100 }
101
102 static void l2cap_sock_init_timer(struct sock *sk)
103 {
104 init_timer(&sk->sk_timer);
105 sk->sk_timer.function = l2cap_sock_timeout;
106 sk->sk_timer.data = (unsigned long)sk;
107 }
108
109 /* ---- L2CAP channels ---- */
110 static struct sock *__l2cap_get_chan_by_dcid(struct l2cap_chan_list *l, u16 cid)
111 {
112 struct sock *s;
113 for (s = l->head; s; s = l2cap_pi(s)->next_c) {
114 if (l2cap_pi(s)->dcid == cid)
115 break;
116 }
117 return s;
118 }
119
120 static struct sock *__l2cap_get_chan_by_scid(struct l2cap_chan_list *l, u16 cid)
121 {
122 struct sock *s;
123 for (s = l->head; s; s = l2cap_pi(s)->next_c) {
124 if (l2cap_pi(s)->scid == cid)
125 break;
126 }
127 return s;
128 }
129
130 /* Find channel with given SCID.
131 * Returns locked socket */
132 static inline struct sock *l2cap_get_chan_by_scid(struct l2cap_chan_list *l, u16 cid)
133 {
134 struct sock *s;
135 read_lock(&l->lock);
136 s = __l2cap_get_chan_by_scid(l, cid);
137 if (s) bh_lock_sock(s);
138 read_unlock(&l->lock);
139 return s;
140 }
141
142 static struct sock *__l2cap_get_chan_by_ident(struct l2cap_chan_list *l, u8 ident)
143 {
144 struct sock *s;
145 for (s = l->head; s; s = l2cap_pi(s)->next_c) {
146 if (l2cap_pi(s)->ident == ident)
147 break;
148 }
149 return s;
150 }
151
152 static inline struct sock *l2cap_get_chan_by_ident(struct l2cap_chan_list *l, u8 ident)
153 {
154 struct sock *s;
155 read_lock(&l->lock);
156 s = __l2cap_get_chan_by_ident(l, ident);
157 if (s) bh_lock_sock(s);
158 read_unlock(&l->lock);
159 return s;
160 }
161
162 static u16 l2cap_alloc_cid(struct l2cap_chan_list *l)
163 {
164 u16 cid = 0x0040;
165
166 for (; cid < 0xffff; cid++) {
167 if(!__l2cap_get_chan_by_scid(l, cid))
168 return cid;
169 }
170
171 return 0;
172 }
173
174 static inline void __l2cap_chan_link(struct l2cap_chan_list *l, struct sock *sk)
175 {
176 sock_hold(sk);
177
178 if (l->head)
179 l2cap_pi(l->head)->prev_c = sk;
180
181 l2cap_pi(sk)->next_c = l->head;
182 l2cap_pi(sk)->prev_c = NULL;
183 l->head = sk;
184 }
185
186 static inline void l2cap_chan_unlink(struct l2cap_chan_list *l, struct sock *sk)
187 {
188 struct sock *next = l2cap_pi(sk)->next_c, *prev = l2cap_pi(sk)->prev_c;
189
190 write_lock_bh(&l->lock);
191 if (sk == l->head)
192 l->head = next;
193
194 if (next)
195 l2cap_pi(next)->prev_c = prev;
196 if (prev)
197 l2cap_pi(prev)->next_c = next;
198 write_unlock_bh(&l->lock);
199
200 __sock_put(sk);
201 }
202
203 static void __l2cap_chan_add(struct l2cap_conn *conn, struct sock *sk, struct sock *parent)
204 {
205 struct l2cap_chan_list *l = &conn->chan_list;
206
207 BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, l2cap_pi(sk)->psm, l2cap_pi(sk)->dcid);
208
209 l2cap_pi(sk)->conn = conn;
210
211 if (sk->sk_type == SOCK_SEQPACKET) {
212 /* Alloc CID for connection-oriented socket */
213 l2cap_pi(sk)->scid = l2cap_alloc_cid(l);
214 } else if (sk->sk_type == SOCK_DGRAM) {
215 /* Connectionless socket */
216 l2cap_pi(sk)->scid = 0x0002;
217 l2cap_pi(sk)->dcid = 0x0002;
218 l2cap_pi(sk)->omtu = L2CAP_DEFAULT_MTU;
219 } else {
220 /* Raw socket can send/recv signalling messages only */
221 l2cap_pi(sk)->scid = 0x0001;
222 l2cap_pi(sk)->dcid = 0x0001;
223 l2cap_pi(sk)->omtu = L2CAP_DEFAULT_MTU;
224 }
225
226 __l2cap_chan_link(l, sk);
227
228 if (parent)
229 bt_accept_enqueue(parent, sk);
230 }
231
232 /* Delete channel.
233 * Must be called on the locked socket. */
234 static void l2cap_chan_del(struct sock *sk, int err)
235 {
236 struct l2cap_conn *conn = l2cap_pi(sk)->conn;
237 struct sock *parent = bt_sk(sk)->parent;
238
239 l2cap_sock_clear_timer(sk);
240
241 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
242
243 if (conn) {
244 /* Unlink from channel list */
245 l2cap_chan_unlink(&conn->chan_list, sk);
246 l2cap_pi(sk)->conn = NULL;
247 hci_conn_put(conn->hcon);
248 }
249
250 sk->sk_state = BT_CLOSED;
251 sock_set_flag(sk, SOCK_ZAPPED);
252
253 if (err)
254 sk->sk_err = err;
255
256 if (parent) {
257 bt_accept_unlink(sk);
258 parent->sk_data_ready(parent, 0);
259 } else
260 sk->sk_state_change(sk);
261 }
262
263 static inline u8 l2cap_get_ident(struct l2cap_conn *conn)
264 {
265 u8 id;
266
267 /* Get next available identificator.
268 * 1 - 128 are used by kernel.
269 * 129 - 199 are reserved.
270 * 200 - 254 are used by utilities like l2ping, etc.
271 */
272
273 spin_lock_bh(&conn->lock);
274
275 if (++conn->tx_ident > 128)
276 conn->tx_ident = 1;
277
278 id = conn->tx_ident;
279
280 spin_unlock_bh(&conn->lock);
281
282 return id;
283 }
284
285 static inline int l2cap_send_cmd(struct l2cap_conn *conn, u8 ident, u8 code, u16 len, void *data)
286 {
287 struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data);
288
289 BT_DBG("code 0x%2.2x", code);
290
291 if (!skb)
292 return -ENOMEM;
293
294 return hci_send_acl(conn->hcon, skb, 0);
295 }
296
297 /* ---- L2CAP connections ---- */
298 static void l2cap_conn_start(struct l2cap_conn *conn)
299 {
300 struct l2cap_chan_list *l = &conn->chan_list;
301 struct sock *sk;
302
303 BT_DBG("conn %p", conn);
304
305 read_lock(&l->lock);
306
307 for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
308 bh_lock_sock(sk);
309
310 if (sk->sk_type != SOCK_SEQPACKET) {
311 l2cap_sock_clear_timer(sk);
312 sk->sk_state = BT_CONNECTED;
313 sk->sk_state_change(sk);
314 } else if (sk->sk_state == BT_CONNECT) {
315 struct l2cap_conn_req req;
316 l2cap_pi(sk)->ident = l2cap_get_ident(conn);
317 req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
318 req.psm = l2cap_pi(sk)->psm;
319 l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
320 L2CAP_CONN_REQ, sizeof(req), &req);
321 }
322
323 bh_unlock_sock(sk);
324 }
325
326 read_unlock(&l->lock);
327 }
328
329 static void l2cap_conn_ready(struct l2cap_conn *conn)
330 {
331 BT_DBG("conn %p", conn);
332
333 if (conn->chan_list.head || !hlist_empty(&l2cap_sk_list.head)) {
334 struct l2cap_info_req req;
335
336 req.type = cpu_to_le16(L2CAP_IT_FEAT_MASK);
337
338 conn->info_state |= L2CAP_INFO_FEAT_MASK_REQ_SENT;
339 conn->info_ident = l2cap_get_ident(conn);
340
341 mod_timer(&conn->info_timer,
342 jiffies + msecs_to_jiffies(L2CAP_INFO_TIMEOUT));
343
344 l2cap_send_cmd(conn, conn->info_ident,
345 L2CAP_INFO_REQ, sizeof(req), &req);
346 }
347 }
348
349 /* Notify sockets that we cannot guaranty reliability anymore */
350 static void l2cap_conn_unreliable(struct l2cap_conn *conn, int err)
351 {
352 struct l2cap_chan_list *l = &conn->chan_list;
353 struct sock *sk;
354
355 BT_DBG("conn %p", conn);
356
357 read_lock(&l->lock);
358
359 for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
360 if (l2cap_pi(sk)->link_mode & L2CAP_LM_RELIABLE)
361 sk->sk_err = err;
362 }
363
364 read_unlock(&l->lock);
365 }
366
367 static void l2cap_info_timeout(unsigned long arg)
368 {
369 struct l2cap_conn *conn = (void *) arg;
370
371 conn->info_ident = 0;
372
373 l2cap_conn_start(conn);
374 }
375
376 static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, u8 status)
377 {
378 struct l2cap_conn *conn = hcon->l2cap_data;
379
380 if (conn || status)
381 return conn;
382
383 conn = kzalloc(sizeof(struct l2cap_conn), GFP_ATOMIC);
384 if (!conn)
385 return NULL;
386
387 hcon->l2cap_data = conn;
388 conn->hcon = hcon;
389
390 BT_DBG("hcon %p conn %p", hcon, conn);
391
392 conn->mtu = hcon->hdev->acl_mtu;
393 conn->src = &hcon->hdev->bdaddr;
394 conn->dst = &hcon->dst;
395
396 conn->feat_mask = 0;
397
398 init_timer(&conn->info_timer);
399 conn->info_timer.function = l2cap_info_timeout;
400 conn->info_timer.data = (unsigned long) conn;
401
402 spin_lock_init(&conn->lock);
403 rwlock_init(&conn->chan_list.lock);
404
405 return conn;
406 }
407
408 static void l2cap_conn_del(struct hci_conn *hcon, int err)
409 {
410 struct l2cap_conn *conn = hcon->l2cap_data;
411 struct sock *sk;
412
413 if (!conn)
414 return;
415
416 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
417
418 if (conn->rx_skb)
419 kfree_skb(conn->rx_skb);
420
421 /* Kill channels */
422 while ((sk = conn->chan_list.head)) {
423 bh_lock_sock(sk);
424 l2cap_chan_del(sk, err);
425 bh_unlock_sock(sk);
426 l2cap_sock_kill(sk);
427 }
428
429 hcon->l2cap_data = NULL;
430 kfree(conn);
431 }
432
433 static inline void l2cap_chan_add(struct l2cap_conn *conn, struct sock *sk, struct sock *parent)
434 {
435 struct l2cap_chan_list *l = &conn->chan_list;
436 write_lock_bh(&l->lock);
437 __l2cap_chan_add(conn, sk, parent);
438 write_unlock_bh(&l->lock);
439 }
440
441 /* ---- Socket interface ---- */
442 static struct sock *__l2cap_get_sock_by_addr(__le16 psm, bdaddr_t *src)
443 {
444 struct sock *sk;
445 struct hlist_node *node;
446 sk_for_each(sk, node, &l2cap_sk_list.head)
447 if (l2cap_pi(sk)->sport == psm && !bacmp(&bt_sk(sk)->src, src))
448 goto found;
449 sk = NULL;
450 found:
451 return sk;
452 }
453
454 /* Find socket with psm and source bdaddr.
455 * Returns closest match.
456 */
457 static struct sock *__l2cap_get_sock_by_psm(int state, __le16 psm, bdaddr_t *src)
458 {
459 struct sock *sk = NULL, *sk1 = NULL;
460 struct hlist_node *node;
461
462 sk_for_each(sk, node, &l2cap_sk_list.head) {
463 if (state && sk->sk_state != state)
464 continue;
465
466 if (l2cap_pi(sk)->psm == psm) {
467 /* Exact match. */
468 if (!bacmp(&bt_sk(sk)->src, src))
469 break;
470
471 /* Closest match */
472 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
473 sk1 = sk;
474 }
475 }
476 return node ? sk : sk1;
477 }
478
479 /* Find socket with given address (psm, src).
480 * Returns locked socket */
481 static inline struct sock *l2cap_get_sock_by_psm(int state, __le16 psm, bdaddr_t *src)
482 {
483 struct sock *s;
484 read_lock(&l2cap_sk_list.lock);
485 s = __l2cap_get_sock_by_psm(state, psm, src);
486 if (s) bh_lock_sock(s);
487 read_unlock(&l2cap_sk_list.lock);
488 return s;
489 }
490
491 static void l2cap_sock_destruct(struct sock *sk)
492 {
493 BT_DBG("sk %p", sk);
494
495 skb_queue_purge(&sk->sk_receive_queue);
496 skb_queue_purge(&sk->sk_write_queue);
497 }
498
499 static void l2cap_sock_cleanup_listen(struct sock *parent)
500 {
501 struct sock *sk;
502
503 BT_DBG("parent %p", parent);
504
505 /* Close not yet accepted channels */
506 while ((sk = bt_accept_dequeue(parent, NULL)))
507 l2cap_sock_close(sk);
508
509 parent->sk_state = BT_CLOSED;
510 sock_set_flag(parent, SOCK_ZAPPED);
511 }
512
513 /* Kill socket (only if zapped and orphan)
514 * Must be called on unlocked socket.
515 */
516 static void l2cap_sock_kill(struct sock *sk)
517 {
518 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
519 return;
520
521 BT_DBG("sk %p state %d", sk, sk->sk_state);
522
523 /* Kill poor orphan */
524 bt_sock_unlink(&l2cap_sk_list, sk);
525 sock_set_flag(sk, SOCK_DEAD);
526 sock_put(sk);
527 }
528
529 static void __l2cap_sock_close(struct sock *sk, int reason)
530 {
531 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
532
533 switch (sk->sk_state) {
534 case BT_LISTEN:
535 l2cap_sock_cleanup_listen(sk);
536 break;
537
538 case BT_CONNECTED:
539 case BT_CONFIG:
540 case BT_CONNECT2:
541 if (sk->sk_type == SOCK_SEQPACKET) {
542 struct l2cap_conn *conn = l2cap_pi(sk)->conn;
543 struct l2cap_disconn_req req;
544
545 sk->sk_state = BT_DISCONN;
546 l2cap_sock_set_timer(sk, sk->sk_sndtimeo);
547
548 req.dcid = cpu_to_le16(l2cap_pi(sk)->dcid);
549 req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
550 l2cap_send_cmd(conn, l2cap_get_ident(conn),
551 L2CAP_DISCONN_REQ, sizeof(req), &req);
552 } else {
553 l2cap_chan_del(sk, reason);
554 }
555 break;
556
557 case BT_CONNECT:
558 case BT_DISCONN:
559 l2cap_chan_del(sk, reason);
560 break;
561
562 default:
563 sock_set_flag(sk, SOCK_ZAPPED);
564 break;
565 }
566 }
567
568 /* Must be called on unlocked socket. */
569 static void l2cap_sock_close(struct sock *sk)
570 {
571 l2cap_sock_clear_timer(sk);
572 lock_sock(sk);
573 __l2cap_sock_close(sk, ECONNRESET);
574 release_sock(sk);
575 l2cap_sock_kill(sk);
576 }
577
578 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
579 {
580 struct l2cap_pinfo *pi = l2cap_pi(sk);
581
582 BT_DBG("sk %p", sk);
583
584 if (parent) {
585 sk->sk_type = parent->sk_type;
586 pi->imtu = l2cap_pi(parent)->imtu;
587 pi->omtu = l2cap_pi(parent)->omtu;
588 pi->link_mode = l2cap_pi(parent)->link_mode;
589 } else {
590 pi->imtu = L2CAP_DEFAULT_MTU;
591 pi->omtu = 0;
592 pi->link_mode = 0;
593 }
594
595 /* Default config options */
596 pi->conf_len = 0;
597 pi->flush_to = L2CAP_DEFAULT_FLUSH_TO;
598 }
599
600 static struct proto l2cap_proto = {
601 .name = "L2CAP",
602 .owner = THIS_MODULE,
603 .obj_size = sizeof(struct l2cap_pinfo)
604 };
605
606 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
607 {
608 struct sock *sk;
609
610 sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
611 if (!sk)
612 return NULL;
613
614 sock_init_data(sock, sk);
615 INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
616
617 sk->sk_destruct = l2cap_sock_destruct;
618 sk->sk_sndtimeo = msecs_to_jiffies(L2CAP_CONN_TIMEOUT);
619
620 sock_reset_flag(sk, SOCK_ZAPPED);
621
622 sk->sk_protocol = proto;
623 sk->sk_state = BT_OPEN;
624
625 l2cap_sock_init_timer(sk);
626
627 bt_sock_link(&l2cap_sk_list, sk);
628 return sk;
629 }
630
631 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol)
632 {
633 struct sock *sk;
634
635 BT_DBG("sock %p", sock);
636
637 sock->state = SS_UNCONNECTED;
638
639 if (sock->type != SOCK_SEQPACKET &&
640 sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
641 return -ESOCKTNOSUPPORT;
642
643 if (sock->type == SOCK_RAW && !capable(CAP_NET_RAW))
644 return -EPERM;
645
646 sock->ops = &l2cap_sock_ops;
647
648 sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
649 if (!sk)
650 return -ENOMEM;
651
652 l2cap_sock_init(sk, NULL);
653 return 0;
654 }
655
656 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
657 {
658 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
659 struct sock *sk = sock->sk;
660 int err = 0;
661
662 BT_DBG("sk %p, %s %d", sk, batostr(&la->l2_bdaddr), la->l2_psm);
663
664 if (!addr || addr->sa_family != AF_BLUETOOTH)
665 return -EINVAL;
666
667 lock_sock(sk);
668
669 if (sk->sk_state != BT_OPEN) {
670 err = -EBADFD;
671 goto done;
672 }
673
674 if (la->l2_psm && btohs(la->l2_psm) < 0x1001 &&
675 !capable(CAP_NET_BIND_SERVICE)) {
676 err = -EACCES;
677 goto done;
678 }
679
680 write_lock_bh(&l2cap_sk_list.lock);
681
682 if (la->l2_psm && __l2cap_get_sock_by_addr(la->l2_psm, &la->l2_bdaddr)) {
683 err = -EADDRINUSE;
684 } else {
685 /* Save source address */
686 bacpy(&bt_sk(sk)->src, &la->l2_bdaddr);
687 l2cap_pi(sk)->psm = la->l2_psm;
688 l2cap_pi(sk)->sport = la->l2_psm;
689 sk->sk_state = BT_BOUND;
690 }
691
692 write_unlock_bh(&l2cap_sk_list.lock);
693
694 done:
695 release_sock(sk);
696 return err;
697 }
698
699 static int l2cap_do_connect(struct sock *sk)
700 {
701 bdaddr_t *src = &bt_sk(sk)->src;
702 bdaddr_t *dst = &bt_sk(sk)->dst;
703 struct l2cap_conn *conn;
704 struct hci_conn *hcon;
705 struct hci_dev *hdev;
706 int err = 0;
707
708 BT_DBG("%s -> %s psm 0x%2.2x", batostr(src), batostr(dst), l2cap_pi(sk)->psm);
709
710 if (!(hdev = hci_get_route(dst, src)))
711 return -EHOSTUNREACH;
712
713 hci_dev_lock_bh(hdev);
714
715 err = -ENOMEM;
716
717 hcon = hci_connect(hdev, ACL_LINK, dst);
718 if (!hcon)
719 goto done;
720
721 conn = l2cap_conn_add(hcon, 0);
722 if (!conn) {
723 hci_conn_put(hcon);
724 goto done;
725 }
726
727 err = 0;
728
729 /* Update source addr of the socket */
730 bacpy(src, conn->src);
731
732 l2cap_chan_add(conn, sk, NULL);
733
734 sk->sk_state = BT_CONNECT;
735 l2cap_sock_set_timer(sk, sk->sk_sndtimeo);
736
737 if (hcon->state == BT_CONNECTED) {
738 if (!(conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT)) {
739 l2cap_conn_ready(conn);
740 goto done;
741 }
742
743 if (sk->sk_type == SOCK_SEQPACKET) {
744 struct l2cap_conn_req req;
745 l2cap_pi(sk)->ident = l2cap_get_ident(conn);
746 req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
747 req.psm = l2cap_pi(sk)->psm;
748 l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
749 L2CAP_CONN_REQ, sizeof(req), &req);
750 } else {
751 l2cap_sock_clear_timer(sk);
752 sk->sk_state = BT_CONNECTED;
753 }
754 }
755
756 done:
757 hci_dev_unlock_bh(hdev);
758 hci_dev_put(hdev);
759 return err;
760 }
761
762 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
763 {
764 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
765 struct sock *sk = sock->sk;
766 int err = 0;
767
768 lock_sock(sk);
769
770 BT_DBG("sk %p", sk);
771
772 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_l2)) {
773 err = -EINVAL;
774 goto done;
775 }
776
777 if (sk->sk_type == SOCK_SEQPACKET && !la->l2_psm) {
778 err = -EINVAL;
779 goto done;
780 }
781
782 switch(sk->sk_state) {
783 case BT_CONNECT:
784 case BT_CONNECT2:
785 case BT_CONFIG:
786 /* Already connecting */
787 goto wait;
788
789 case BT_CONNECTED:
790 /* Already connected */
791 goto done;
792
793 case BT_OPEN:
794 case BT_BOUND:
795 /* Can connect */
796 break;
797
798 default:
799 err = -EBADFD;
800 goto done;
801 }
802
803 /* Set destination address and psm */
804 bacpy(&bt_sk(sk)->dst, &la->l2_bdaddr);
805 l2cap_pi(sk)->psm = la->l2_psm;
806
807 if ((err = l2cap_do_connect(sk)))
808 goto done;
809
810 wait:
811 err = bt_sock_wait_state(sk, BT_CONNECTED,
812 sock_sndtimeo(sk, flags & O_NONBLOCK));
813 done:
814 release_sock(sk);
815 return err;
816 }
817
818 static int l2cap_sock_listen(struct socket *sock, int backlog)
819 {
820 struct sock *sk = sock->sk;
821 int err = 0;
822
823 BT_DBG("sk %p backlog %d", sk, backlog);
824
825 lock_sock(sk);
826
827 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
828 err = -EBADFD;
829 goto done;
830 }
831
832 if (!l2cap_pi(sk)->psm) {
833 bdaddr_t *src = &bt_sk(sk)->src;
834 u16 psm;
835
836 err = -EINVAL;
837
838 write_lock_bh(&l2cap_sk_list.lock);
839
840 for (psm = 0x1001; psm < 0x1100; psm += 2)
841 if (!__l2cap_get_sock_by_addr(htobs(psm), src)) {
842 l2cap_pi(sk)->psm = htobs(psm);
843 l2cap_pi(sk)->sport = htobs(psm);
844 err = 0;
845 break;
846 }
847
848 write_unlock_bh(&l2cap_sk_list.lock);
849
850 if (err < 0)
851 goto done;
852 }
853
854 sk->sk_max_ack_backlog = backlog;
855 sk->sk_ack_backlog = 0;
856 sk->sk_state = BT_LISTEN;
857
858 done:
859 release_sock(sk);
860 return err;
861 }
862
863 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
864 {
865 DECLARE_WAITQUEUE(wait, current);
866 struct sock *sk = sock->sk, *nsk;
867 long timeo;
868 int err = 0;
869
870 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
871
872 if (sk->sk_state != BT_LISTEN) {
873 err = -EBADFD;
874 goto done;
875 }
876
877 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
878
879 BT_DBG("sk %p timeo %ld", sk, timeo);
880
881 /* Wait for an incoming connection. (wake-one). */
882 add_wait_queue_exclusive(sk->sk_sleep, &wait);
883 while (!(nsk = bt_accept_dequeue(sk, newsock))) {
884 set_current_state(TASK_INTERRUPTIBLE);
885 if (!timeo) {
886 err = -EAGAIN;
887 break;
888 }
889
890 release_sock(sk);
891 timeo = schedule_timeout(timeo);
892 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
893
894 if (sk->sk_state != BT_LISTEN) {
895 err = -EBADFD;
896 break;
897 }
898
899 if (signal_pending(current)) {
900 err = sock_intr_errno(timeo);
901 break;
902 }
903 }
904 set_current_state(TASK_RUNNING);
905 remove_wait_queue(sk->sk_sleep, &wait);
906
907 if (err)
908 goto done;
909
910 newsock->state = SS_CONNECTED;
911
912 BT_DBG("new socket %p", nsk);
913
914 done:
915 release_sock(sk);
916 return err;
917 }
918
919 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
920 {
921 struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
922 struct sock *sk = sock->sk;
923
924 BT_DBG("sock %p, sk %p", sock, sk);
925
926 addr->sa_family = AF_BLUETOOTH;
927 *len = sizeof(struct sockaddr_l2);
928
929 if (peer)
930 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
931 else
932 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
933
934 la->l2_psm = l2cap_pi(sk)->psm;
935 return 0;
936 }
937
938 static inline int l2cap_do_send(struct sock *sk, struct msghdr *msg, int len)
939 {
940 struct l2cap_conn *conn = l2cap_pi(sk)->conn;
941 struct sk_buff *skb, **frag;
942 int err, hlen, count, sent=0;
943 struct l2cap_hdr *lh;
944
945 BT_DBG("sk %p len %d", sk, len);
946
947 /* First fragment (with L2CAP header) */
948 if (sk->sk_type == SOCK_DGRAM)
949 hlen = L2CAP_HDR_SIZE + 2;
950 else
951 hlen = L2CAP_HDR_SIZE;
952
953 count = min_t(unsigned int, (conn->mtu - hlen), len);
954
955 skb = bt_skb_send_alloc(sk, hlen + count,
956 msg->msg_flags & MSG_DONTWAIT, &err);
957 if (!skb)
958 return err;
959
960 /* Create L2CAP header */
961 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
962 lh->cid = cpu_to_le16(l2cap_pi(sk)->dcid);
963 lh->len = cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));
964
965 if (sk->sk_type == SOCK_DGRAM)
966 put_unaligned(l2cap_pi(sk)->psm, (__le16 *) skb_put(skb, 2));
967
968 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
969 err = -EFAULT;
970 goto fail;
971 }
972
973 sent += count;
974 len -= count;
975
976 /* Continuation fragments (no L2CAP header) */
977 frag = &skb_shinfo(skb)->frag_list;
978 while (len) {
979 count = min_t(unsigned int, conn->mtu, len);
980
981 *frag = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err);
982 if (!*frag)
983 goto fail;
984
985 if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) {
986 err = -EFAULT;
987 goto fail;
988 }
989
990 sent += count;
991 len -= count;
992
993 frag = &(*frag)->next;
994 }
995
996 if ((err = hci_send_acl(conn->hcon, skb, 0)) < 0)
997 goto fail;
998
999 return sent;
1000
1001 fail:
1002 kfree_skb(skb);
1003 return err;
1004 }
1005
1006 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
1007 {
1008 struct sock *sk = sock->sk;
1009 int err = 0;
1010
1011 BT_DBG("sock %p, sk %p", sock, sk);
1012
1013 err = sock_error(sk);
1014 if (err)
1015 return err;
1016
1017 if (msg->msg_flags & MSG_OOB)
1018 return -EOPNOTSUPP;
1019
1020 /* Check outgoing MTU */
1021 if (sk->sk_type != SOCK_RAW && len > l2cap_pi(sk)->omtu)
1022 return -EINVAL;
1023
1024 lock_sock(sk);
1025
1026 if (sk->sk_state == BT_CONNECTED)
1027 err = l2cap_do_send(sk, msg, len);
1028 else
1029 err = -ENOTCONN;
1030
1031 release_sock(sk);
1032 return err;
1033 }
1034
1035 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
1036 {
1037 struct sock *sk = sock->sk;
1038 struct l2cap_options opts;
1039 int err = 0, len;
1040 u32 opt;
1041
1042 BT_DBG("sk %p", sk);
1043
1044 lock_sock(sk);
1045
1046 switch (optname) {
1047 case L2CAP_OPTIONS:
1048 opts.imtu = l2cap_pi(sk)->imtu;
1049 opts.omtu = l2cap_pi(sk)->omtu;
1050 opts.flush_to = l2cap_pi(sk)->flush_to;
1051 opts.mode = L2CAP_MODE_BASIC;
1052
1053 len = min_t(unsigned int, sizeof(opts), optlen);
1054 if (copy_from_user((char *) &opts, optval, len)) {
1055 err = -EFAULT;
1056 break;
1057 }
1058
1059 l2cap_pi(sk)->imtu = opts.imtu;
1060 l2cap_pi(sk)->omtu = opts.omtu;
1061 break;
1062
1063 case L2CAP_LM:
1064 if (get_user(opt, (u32 __user *) optval)) {
1065 err = -EFAULT;
1066 break;
1067 }
1068
1069 l2cap_pi(sk)->link_mode = opt;
1070 break;
1071
1072 default:
1073 err = -ENOPROTOOPT;
1074 break;
1075 }
1076
1077 release_sock(sk);
1078 return err;
1079 }
1080
1081 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
1082 {
1083 struct sock *sk = sock->sk;
1084 struct l2cap_options opts;
1085 struct l2cap_conninfo cinfo;
1086 int len, err = 0;
1087
1088 BT_DBG("sk %p", sk);
1089
1090 if (get_user(len, optlen))
1091 return -EFAULT;
1092
1093 lock_sock(sk);
1094
1095 switch (optname) {
1096 case L2CAP_OPTIONS:
1097 opts.imtu = l2cap_pi(sk)->imtu;
1098 opts.omtu = l2cap_pi(sk)->omtu;
1099 opts.flush_to = l2cap_pi(sk)->flush_to;
1100 opts.mode = L2CAP_MODE_BASIC;
1101
1102 len = min_t(unsigned int, len, sizeof(opts));
1103 if (copy_to_user(optval, (char *) &opts, len))
1104 err = -EFAULT;
1105
1106 break;
1107
1108 case L2CAP_LM:
1109 if (put_user(l2cap_pi(sk)->link_mode, (u32 __user *) optval))
1110 err = -EFAULT;
1111 break;
1112
1113 case L2CAP_CONNINFO:
1114 if (sk->sk_state != BT_CONNECTED) {
1115 err = -ENOTCONN;
1116 break;
1117 }
1118
1119 cinfo.hci_handle = l2cap_pi(sk)->conn->hcon->handle;
1120 memcpy(cinfo.dev_class, l2cap_pi(sk)->conn->hcon->dev_class, 3);
1121
1122 len = min_t(unsigned int, len, sizeof(cinfo));
1123 if (copy_to_user(optval, (char *) &cinfo, len))
1124 err = -EFAULT;
1125
1126 break;
1127
1128 default:
1129 err = -ENOPROTOOPT;
1130 break;
1131 }
1132
1133 release_sock(sk);
1134 return err;
1135 }
1136
1137 static int l2cap_sock_shutdown(struct socket *sock, int how)
1138 {
1139 struct sock *sk = sock->sk;
1140 int err = 0;
1141
1142 BT_DBG("sock %p, sk %p", sock, sk);
1143
1144 if (!sk)
1145 return 0;
1146
1147 lock_sock(sk);
1148 if (!sk->sk_shutdown) {
1149 sk->sk_shutdown = SHUTDOWN_MASK;
1150 l2cap_sock_clear_timer(sk);
1151 __l2cap_sock_close(sk, 0);
1152
1153 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
1154 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
1155 }
1156 release_sock(sk);
1157 return err;
1158 }
1159
1160 static int l2cap_sock_release(struct socket *sock)
1161 {
1162 struct sock *sk = sock->sk;
1163 int err;
1164
1165 BT_DBG("sock %p, sk %p", sock, sk);
1166
1167 if (!sk)
1168 return 0;
1169
1170 err = l2cap_sock_shutdown(sock, 2);
1171
1172 sock_orphan(sk);
1173 l2cap_sock_kill(sk);
1174 return err;
1175 }
1176
1177 static void l2cap_chan_ready(struct sock *sk)
1178 {
1179 struct sock *parent = bt_sk(sk)->parent;
1180
1181 BT_DBG("sk %p, parent %p", sk, parent);
1182
1183 l2cap_pi(sk)->conf_state = 0;
1184 l2cap_sock_clear_timer(sk);
1185
1186 if (!parent) {
1187 /* Outgoing channel.
1188 * Wake up socket sleeping on connect.
1189 */
1190 sk->sk_state = BT_CONNECTED;
1191 sk->sk_state_change(sk);
1192 } else {
1193 /* Incoming channel.
1194 * Wake up socket sleeping on accept.
1195 */
1196 parent->sk_data_ready(parent, 0);
1197 }
1198 }
1199
1200 /* Copy frame to all raw sockets on that connection */
1201 static void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
1202 {
1203 struct l2cap_chan_list *l = &conn->chan_list;
1204 struct sk_buff *nskb;
1205 struct sock * sk;
1206
1207 BT_DBG("conn %p", conn);
1208
1209 read_lock(&l->lock);
1210 for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
1211 if (sk->sk_type != SOCK_RAW)
1212 continue;
1213
1214 /* Don't send frame to the socket it came from */
1215 if (skb->sk == sk)
1216 continue;
1217
1218 if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
1219 continue;
1220
1221 if (sock_queue_rcv_skb(sk, nskb))
1222 kfree_skb(nskb);
1223 }
1224 read_unlock(&l->lock);
1225 }
1226
1227 /* ---- L2CAP signalling commands ---- */
1228 static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
1229 u8 code, u8 ident, u16 dlen, void *data)
1230 {
1231 struct sk_buff *skb, **frag;
1232 struct l2cap_cmd_hdr *cmd;
1233 struct l2cap_hdr *lh;
1234 int len, count;
1235
1236 BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %d", conn, code, ident, dlen);
1237
1238 len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen;
1239 count = min_t(unsigned int, conn->mtu, len);
1240
1241 skb = bt_skb_alloc(count, GFP_ATOMIC);
1242 if (!skb)
1243 return NULL;
1244
1245 lh = (struct l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
1246 lh->len = cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen);
1247 lh->cid = cpu_to_le16(0x0001);
1248
1249 cmd = (struct l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE);
1250 cmd->code = code;
1251 cmd->ident = ident;
1252 cmd->len = cpu_to_le16(dlen);
1253
1254 if (dlen) {
1255 count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE;
1256 memcpy(skb_put(skb, count), data, count);
1257 data += count;
1258 }
1259
1260 len -= skb->len;
1261
1262 /* Continuation fragments (no L2CAP header) */
1263 frag = &skb_shinfo(skb)->frag_list;
1264 while (len) {
1265 count = min_t(unsigned int, conn->mtu, len);
1266
1267 *frag = bt_skb_alloc(count, GFP_ATOMIC);
1268 if (!*frag)
1269 goto fail;
1270
1271 memcpy(skb_put(*frag, count), data, count);
1272
1273 len -= count;
1274 data += count;
1275
1276 frag = &(*frag)->next;
1277 }
1278
1279 return skb;
1280
1281 fail:
1282 kfree_skb(skb);
1283 return NULL;
1284 }
1285
1286 static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, unsigned long *val)
1287 {
1288 struct l2cap_conf_opt *opt = *ptr;
1289 int len;
1290
1291 len = L2CAP_CONF_OPT_SIZE + opt->len;
1292 *ptr += len;
1293
1294 *type = opt->type;
1295 *olen = opt->len;
1296
1297 switch (opt->len) {
1298 case 1:
1299 *val = *((u8 *) opt->val);
1300 break;
1301
1302 case 2:
1303 *val = __le16_to_cpu(*((__le16 *) opt->val));
1304 break;
1305
1306 case 4:
1307 *val = __le32_to_cpu(*((__le32 *) opt->val));
1308 break;
1309
1310 default:
1311 *val = (unsigned long) opt->val;
1312 break;
1313 }
1314
1315 BT_DBG("type 0x%2.2x len %d val 0x%lx", *type, opt->len, *val);
1316 return len;
1317 }
1318
1319 static void l2cap_add_conf_opt(void **ptr, u8 type, u8 len, unsigned long val)
1320 {
1321 struct l2cap_conf_opt *opt = *ptr;
1322
1323 BT_DBG("type 0x%2.2x len %d val 0x%lx", type, len, val);
1324
1325 opt->type = type;
1326 opt->len = len;
1327
1328 switch (len) {
1329 case 1:
1330 *((u8 *) opt->val) = val;
1331 break;
1332
1333 case 2:
1334 *((__le16 *) opt->val) = cpu_to_le16(val);
1335 break;
1336
1337 case 4:
1338 *((__le32 *) opt->val) = cpu_to_le32(val);
1339 break;
1340
1341 default:
1342 memcpy(opt->val, (void *) val, len);
1343 break;
1344 }
1345
1346 *ptr += L2CAP_CONF_OPT_SIZE + len;
1347 }
1348
1349 static int l2cap_build_conf_req(struct sock *sk, void *data)
1350 {
1351 struct l2cap_pinfo *pi = l2cap_pi(sk);
1352 struct l2cap_conf_req *req = data;
1353 void *ptr = req->data;
1354
1355 BT_DBG("sk %p", sk);
1356
1357 if (pi->imtu != L2CAP_DEFAULT_MTU)
1358 l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, pi->imtu);
1359
1360 /* FIXME: Need actual value of the flush timeout */
1361 //if (flush_to != L2CAP_DEFAULT_FLUSH_TO)
1362 // l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 2, pi->flush_to);
1363
1364 req->dcid = cpu_to_le16(pi->dcid);
1365 req->flags = cpu_to_le16(0);
1366
1367 return ptr - data;
1368 }
1369
1370 static int l2cap_parse_conf_req(struct sock *sk, void *data)
1371 {
1372 struct l2cap_pinfo *pi = l2cap_pi(sk);
1373 struct l2cap_conf_rsp *rsp = data;
1374 void *ptr = rsp->data;
1375 void *req = pi->conf_req;
1376 int len = pi->conf_len;
1377 int type, hint, olen;
1378 unsigned long val;
1379 struct l2cap_conf_rfc rfc = { .mode = L2CAP_MODE_BASIC };
1380 u16 mtu = L2CAP_DEFAULT_MTU;
1381 u16 result = L2CAP_CONF_SUCCESS;
1382
1383 BT_DBG("sk %p", sk);
1384
1385 while (len >= L2CAP_CONF_OPT_SIZE) {
1386 len -= l2cap_get_conf_opt(&req, &type, &olen, &val);
1387
1388 hint = type & 0x80;
1389 type &= 0x7f;
1390
1391 switch (type) {
1392 case L2CAP_CONF_MTU:
1393 mtu = val;
1394 break;
1395
1396 case L2CAP_CONF_FLUSH_TO:
1397 pi->flush_to = val;
1398 break;
1399
1400 case L2CAP_CONF_QOS:
1401 break;
1402
1403 case L2CAP_CONF_RFC:
1404 if (olen == sizeof(rfc))
1405 memcpy(&rfc, (void *) val, olen);
1406 break;
1407
1408 default:
1409 if (hint)
1410 break;
1411
1412 result = L2CAP_CONF_UNKNOWN;
1413 *((u8 *) ptr++) = type;
1414 break;
1415 }
1416 }
1417
1418 if (result == L2CAP_CONF_SUCCESS) {
1419 /* Configure output options and let the other side know
1420 * which ones we don't like. */
1421
1422 if (rfc.mode == L2CAP_MODE_BASIC) {
1423 if (mtu < pi->omtu)
1424 result = L2CAP_CONF_UNACCEPT;
1425 else {
1426 pi->omtu = mtu;
1427 pi->conf_state |= L2CAP_CONF_OUTPUT_DONE;
1428 }
1429
1430 l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, pi->omtu);
1431 } else {
1432 result = L2CAP_CONF_UNACCEPT;
1433
1434 memset(&rfc, 0, sizeof(rfc));
1435 rfc.mode = L2CAP_MODE_BASIC;
1436
1437 l2cap_add_conf_opt(&ptr, L2CAP_CONF_RFC,
1438 sizeof(rfc), (unsigned long) &rfc);
1439 }
1440 }
1441
1442 rsp->scid = cpu_to_le16(pi->dcid);
1443 rsp->result = cpu_to_le16(result);
1444 rsp->flags = cpu_to_le16(0x0000);
1445
1446 return ptr - data;
1447 }
1448
1449 static int l2cap_build_conf_rsp(struct sock *sk, void *data, u16 result, u16 flags)
1450 {
1451 struct l2cap_conf_rsp *rsp = data;
1452 void *ptr = rsp->data;
1453
1454 BT_DBG("sk %p", sk);
1455
1456 rsp->scid = cpu_to_le16(l2cap_pi(sk)->dcid);
1457 rsp->result = cpu_to_le16(result);
1458 rsp->flags = cpu_to_le16(flags);
1459
1460 return ptr - data;
1461 }
1462
1463 static inline int l2cap_command_rej(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
1464 {
1465 struct l2cap_cmd_rej *rej = (struct l2cap_cmd_rej *) data;
1466
1467 if (rej->reason != 0x0000)
1468 return 0;
1469
1470 if ((conn->info_state & L2CAP_INFO_FEAT_MASK_REQ_SENT) &&
1471 cmd->ident == conn->info_ident) {
1472 conn->info_ident = 0;
1473 del_timer(&conn->info_timer);
1474 l2cap_conn_start(conn);
1475 }
1476
1477 return 0;
1478 }
1479
1480 static inline int l2cap_connect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
1481 {
1482 struct l2cap_chan_list *list = &conn->chan_list;
1483 struct l2cap_conn_req *req = (struct l2cap_conn_req *) data;
1484 struct l2cap_conn_rsp rsp;
1485 struct sock *sk, *parent;
1486 int result = 0, status = 0;
1487
1488 u16 dcid = 0, scid = __le16_to_cpu(req->scid);
1489 __le16 psm = req->psm;
1490
1491 BT_DBG("psm 0x%2.2x scid 0x%4.4x", psm, scid);
1492
1493 /* Check if we have socket listening on psm */
1494 parent = l2cap_get_sock_by_psm(BT_LISTEN, psm, conn->src);
1495 if (!parent) {
1496 result = L2CAP_CR_BAD_PSM;
1497 goto sendresp;
1498 }
1499
1500 result = L2CAP_CR_NO_MEM;
1501
1502 /* Check for backlog size */
1503 if (sk_acceptq_is_full(parent)) {
1504 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1505 goto response;
1506 }
1507
1508 sk = l2cap_sock_alloc(parent->sk_net, NULL, BTPROTO_L2CAP, GFP_ATOMIC);
1509 if (!sk)
1510 goto response;
1511
1512 write_lock_bh(&list->lock);
1513
1514 /* Check if we already have channel with that dcid */
1515 if (__l2cap_get_chan_by_dcid(list, scid)) {
1516 write_unlock_bh(&list->lock);
1517 sock_set_flag(sk, SOCK_ZAPPED);
1518 l2cap_sock_kill(sk);
1519 goto response;
1520 }
1521
1522 hci_conn_hold(conn->hcon);
1523
1524 l2cap_sock_init(sk, parent);
1525 bacpy(&bt_sk(sk)->src, conn->src);
1526 bacpy(&bt_sk(sk)->dst, conn->dst);
1527 l2cap_pi(sk)->psm = psm;
1528 l2cap_pi(sk)->dcid = scid;
1529
1530 __l2cap_chan_add(conn, sk, parent);
1531 dcid = l2cap_pi(sk)->scid;
1532
1533 l2cap_sock_set_timer(sk, sk->sk_sndtimeo);
1534
1535 /* Service level security */
1536 result = L2CAP_CR_PEND;
1537 status = L2CAP_CS_AUTHEN_PEND;
1538 sk->sk_state = BT_CONNECT2;
1539 l2cap_pi(sk)->ident = cmd->ident;
1540
1541 if ((l2cap_pi(sk)->link_mode & L2CAP_LM_ENCRYPT) ||
1542 (l2cap_pi(sk)->link_mode & L2CAP_LM_SECURE)) {
1543 if (!hci_conn_encrypt(conn->hcon))
1544 goto done;
1545 } else if (l2cap_pi(sk)->link_mode & L2CAP_LM_AUTH) {
1546 if (!hci_conn_auth(conn->hcon))
1547 goto done;
1548 }
1549
1550 sk->sk_state = BT_CONFIG;
1551 result = status = 0;
1552
1553 done:
1554 write_unlock_bh(&list->lock);
1555
1556 response:
1557 bh_unlock_sock(parent);
1558
1559 sendresp:
1560 rsp.scid = cpu_to_le16(scid);
1561 rsp.dcid = cpu_to_le16(dcid);
1562 rsp.result = cpu_to_le16(result);
1563 rsp.status = cpu_to_le16(status);
1564 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONN_RSP, sizeof(rsp), &rsp);
1565 return 0;
1566 }
1567
1568 static inline int l2cap_connect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
1569 {
1570 struct l2cap_conn_rsp *rsp = (struct l2cap_conn_rsp *) data;
1571 u16 scid, dcid, result, status;
1572 struct sock *sk;
1573 u8 req[128];
1574
1575 scid = __le16_to_cpu(rsp->scid);
1576 dcid = __le16_to_cpu(rsp->dcid);
1577 result = __le16_to_cpu(rsp->result);
1578 status = __le16_to_cpu(rsp->status);
1579
1580 BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", dcid, scid, result, status);
1581
1582 if (scid) {
1583 if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, scid)))
1584 return 0;
1585 } else {
1586 if (!(sk = l2cap_get_chan_by_ident(&conn->chan_list, cmd->ident)))
1587 return 0;
1588 }
1589
1590 switch (result) {
1591 case L2CAP_CR_SUCCESS:
1592 sk->sk_state = BT_CONFIG;
1593 l2cap_pi(sk)->ident = 0;
1594 l2cap_pi(sk)->dcid = dcid;
1595 l2cap_pi(sk)->conf_state |= L2CAP_CONF_REQ_SENT;
1596
1597 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
1598 l2cap_build_conf_req(sk, req), req);
1599 break;
1600
1601 case L2CAP_CR_PEND:
1602 break;
1603
1604 default:
1605 l2cap_chan_del(sk, ECONNREFUSED);
1606 break;
1607 }
1608
1609 bh_unlock_sock(sk);
1610 return 0;
1611 }
1612
1613 static inline int l2cap_config_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u16 cmd_len, u8 *data)
1614 {
1615 struct l2cap_conf_req *req = (struct l2cap_conf_req *) data;
1616 u16 dcid, flags;
1617 u8 rsp[64];
1618 struct sock *sk;
1619 int len;
1620
1621 dcid = __le16_to_cpu(req->dcid);
1622 flags = __le16_to_cpu(req->flags);
1623
1624 BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags);
1625
1626 if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, dcid)))
1627 return -ENOENT;
1628
1629 if (sk->sk_state == BT_DISCONN)
1630 goto unlock;
1631
1632 /* Reject if config buffer is too small. */
1633 len = cmd_len - sizeof(*req);
1634 if (l2cap_pi(sk)->conf_len + len > sizeof(l2cap_pi(sk)->conf_req)) {
1635 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
1636 l2cap_build_conf_rsp(sk, rsp,
1637 L2CAP_CONF_REJECT, flags), rsp);
1638 goto unlock;
1639 }
1640
1641 /* Store config. */
1642 memcpy(l2cap_pi(sk)->conf_req + l2cap_pi(sk)->conf_len, req->data, len);
1643 l2cap_pi(sk)->conf_len += len;
1644
1645 if (flags & 0x0001) {
1646 /* Incomplete config. Send empty response. */
1647 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP,
1648 l2cap_build_conf_rsp(sk, rsp,
1649 L2CAP_CONF_SUCCESS, 0x0001), rsp);
1650 goto unlock;
1651 }
1652
1653 /* Complete config. */
1654 len = l2cap_parse_conf_req(sk, rsp);
1655 if (len < 0)
1656 goto unlock;
1657
1658 l2cap_send_cmd(conn, cmd->ident, L2CAP_CONF_RSP, len, rsp);
1659
1660 /* Reset config buffer. */
1661 l2cap_pi(sk)->conf_len = 0;
1662
1663 if (!(l2cap_pi(sk)->conf_state & L2CAP_CONF_OUTPUT_DONE))
1664 goto unlock;
1665
1666 if (l2cap_pi(sk)->conf_state & L2CAP_CONF_INPUT_DONE) {
1667 sk->sk_state = BT_CONNECTED;
1668 l2cap_chan_ready(sk);
1669 goto unlock;
1670 }
1671
1672 if (!(l2cap_pi(sk)->conf_state & L2CAP_CONF_REQ_SENT)) {
1673 u8 req[64];
1674 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
1675 l2cap_build_conf_req(sk, req), req);
1676 }
1677
1678 unlock:
1679 bh_unlock_sock(sk);
1680 return 0;
1681 }
1682
1683 static inline int l2cap_config_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
1684 {
1685 struct l2cap_conf_rsp *rsp = (struct l2cap_conf_rsp *)data;
1686 u16 scid, flags, result;
1687 struct sock *sk;
1688
1689 scid = __le16_to_cpu(rsp->scid);
1690 flags = __le16_to_cpu(rsp->flags);
1691 result = __le16_to_cpu(rsp->result);
1692
1693 BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x", scid, flags, result);
1694
1695 if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, scid)))
1696 return 0;
1697
1698 switch (result) {
1699 case L2CAP_CONF_SUCCESS:
1700 break;
1701
1702 case L2CAP_CONF_UNACCEPT:
1703 if (++l2cap_pi(sk)->conf_retry < L2CAP_CONF_MAX_RETRIES) {
1704 char req[128];
1705 /* It does not make sense to adjust L2CAP parameters
1706 * that are currently defined in the spec. We simply
1707 * resend config request that we sent earlier. It is
1708 * stupid, but it helps qualification testing which
1709 * expects at least some response from us. */
1710 l2cap_send_cmd(conn, l2cap_get_ident(conn), L2CAP_CONF_REQ,
1711 l2cap_build_conf_req(sk, req), req);
1712 goto done;
1713 }
1714
1715 default:
1716 sk->sk_state = BT_DISCONN;
1717 sk->sk_err = ECONNRESET;
1718 l2cap_sock_set_timer(sk, HZ * 5);
1719 {
1720 struct l2cap_disconn_req req;
1721 req.dcid = cpu_to_le16(l2cap_pi(sk)->dcid);
1722 req.scid = cpu_to_le16(l2cap_pi(sk)->scid);
1723 l2cap_send_cmd(conn, l2cap_get_ident(conn),
1724 L2CAP_DISCONN_REQ, sizeof(req), &req);
1725 }
1726 goto done;
1727 }
1728
1729 if (flags & 0x01)
1730 goto done;
1731
1732 l2cap_pi(sk)->conf_state |= L2CAP_CONF_INPUT_DONE;
1733
1734 if (l2cap_pi(sk)->conf_state & L2CAP_CONF_OUTPUT_DONE) {
1735 sk->sk_state = BT_CONNECTED;
1736 l2cap_chan_ready(sk);
1737 }
1738
1739 done:
1740 bh_unlock_sock(sk);
1741 return 0;
1742 }
1743
1744 static inline int l2cap_disconnect_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
1745 {
1746 struct l2cap_disconn_req *req = (struct l2cap_disconn_req *) data;
1747 struct l2cap_disconn_rsp rsp;
1748 u16 dcid, scid;
1749 struct sock *sk;
1750
1751 scid = __le16_to_cpu(req->scid);
1752 dcid = __le16_to_cpu(req->dcid);
1753
1754 BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid);
1755
1756 if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, dcid)))
1757 return 0;
1758
1759 rsp.dcid = cpu_to_le16(l2cap_pi(sk)->scid);
1760 rsp.scid = cpu_to_le16(l2cap_pi(sk)->dcid);
1761 l2cap_send_cmd(conn, cmd->ident, L2CAP_DISCONN_RSP, sizeof(rsp), &rsp);
1762
1763 sk->sk_shutdown = SHUTDOWN_MASK;
1764
1765 l2cap_chan_del(sk, ECONNRESET);
1766 bh_unlock_sock(sk);
1767
1768 l2cap_sock_kill(sk);
1769 return 0;
1770 }
1771
1772 static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
1773 {
1774 struct l2cap_disconn_rsp *rsp = (struct l2cap_disconn_rsp *) data;
1775 u16 dcid, scid;
1776 struct sock *sk;
1777
1778 scid = __le16_to_cpu(rsp->scid);
1779 dcid = __le16_to_cpu(rsp->dcid);
1780
1781 BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid);
1782
1783 if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, scid)))
1784 return 0;
1785
1786 l2cap_chan_del(sk, 0);
1787 bh_unlock_sock(sk);
1788
1789 l2cap_sock_kill(sk);
1790 return 0;
1791 }
1792
1793 static inline int l2cap_information_req(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
1794 {
1795 struct l2cap_info_req *req = (struct l2cap_info_req *) data;
1796 u16 type;
1797
1798 type = __le16_to_cpu(req->type);
1799
1800 BT_DBG("type 0x%4.4x", type);
1801
1802 if (type == L2CAP_IT_FEAT_MASK) {
1803 u8 buf[8];
1804 struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) buf;
1805 rsp->type = cpu_to_le16(L2CAP_IT_FEAT_MASK);
1806 rsp->result = cpu_to_le16(L2CAP_IR_SUCCESS);
1807 put_unaligned(cpu_to_le32(l2cap_feat_mask), (__le32 *) rsp->data);
1808 l2cap_send_cmd(conn, cmd->ident,
1809 L2CAP_INFO_RSP, sizeof(buf), buf);
1810 } else {
1811 struct l2cap_info_rsp rsp;
1812 rsp.type = cpu_to_le16(type);
1813 rsp.result = cpu_to_le16(L2CAP_IR_NOTSUPP);
1814 l2cap_send_cmd(conn, cmd->ident,
1815 L2CAP_INFO_RSP, sizeof(rsp), &rsp);
1816 }
1817
1818 return 0;
1819 }
1820
1821 static inline int l2cap_information_rsp(struct l2cap_conn *conn, struct l2cap_cmd_hdr *cmd, u8 *data)
1822 {
1823 struct l2cap_info_rsp *rsp = (struct l2cap_info_rsp *) data;
1824 u16 type, result;
1825
1826 type = __le16_to_cpu(rsp->type);
1827 result = __le16_to_cpu(rsp->result);
1828
1829 BT_DBG("type 0x%4.4x result 0x%2.2x", type, result);
1830
1831 conn->info_ident = 0;
1832
1833 del_timer(&conn->info_timer);
1834
1835 if (type == L2CAP_IT_FEAT_MASK)
1836 conn->feat_mask = __le32_to_cpu(get_unaligned((__le32 *) rsp->data));
1837
1838 l2cap_conn_start(conn);
1839
1840 return 0;
1841 }
1842
1843 static inline void l2cap_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
1844 {
1845 u8 *data = skb->data;
1846 int len = skb->len;
1847 struct l2cap_cmd_hdr cmd;
1848 int err = 0;
1849
1850 l2cap_raw_recv(conn, skb);
1851
1852 while (len >= L2CAP_CMD_HDR_SIZE) {
1853 u16 cmd_len;
1854 memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE);
1855 data += L2CAP_CMD_HDR_SIZE;
1856 len -= L2CAP_CMD_HDR_SIZE;
1857
1858 cmd_len = le16_to_cpu(cmd.len);
1859
1860 BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd_len, cmd.ident);
1861
1862 if (cmd_len > len || !cmd.ident) {
1863 BT_DBG("corrupted command");
1864 break;
1865 }
1866
1867 switch (cmd.code) {
1868 case L2CAP_COMMAND_REJ:
1869 l2cap_command_rej(conn, &cmd, data);
1870 break;
1871
1872 case L2CAP_CONN_REQ:
1873 err = l2cap_connect_req(conn, &cmd, data);
1874 break;
1875
1876 case L2CAP_CONN_RSP:
1877 err = l2cap_connect_rsp(conn, &cmd, data);
1878 break;
1879
1880 case L2CAP_CONF_REQ:
1881 err = l2cap_config_req(conn, &cmd, cmd_len, data);
1882 break;
1883
1884 case L2CAP_CONF_RSP:
1885 err = l2cap_config_rsp(conn, &cmd, data);
1886 break;
1887
1888 case L2CAP_DISCONN_REQ:
1889 err = l2cap_disconnect_req(conn, &cmd, data);
1890 break;
1891
1892 case L2CAP_DISCONN_RSP:
1893 err = l2cap_disconnect_rsp(conn, &cmd, data);
1894 break;
1895
1896 case L2CAP_ECHO_REQ:
1897 l2cap_send_cmd(conn, cmd.ident, L2CAP_ECHO_RSP, cmd_len, data);
1898 break;
1899
1900 case L2CAP_ECHO_RSP:
1901 break;
1902
1903 case L2CAP_INFO_REQ:
1904 err = l2cap_information_req(conn, &cmd, data);
1905 break;
1906
1907 case L2CAP_INFO_RSP:
1908 err = l2cap_information_rsp(conn, &cmd, data);
1909 break;
1910
1911 default:
1912 BT_ERR("Unknown signaling command 0x%2.2x", cmd.code);
1913 err = -EINVAL;
1914 break;
1915 }
1916
1917 if (err) {
1918 struct l2cap_cmd_rej rej;
1919 BT_DBG("error %d", err);
1920
1921 /* FIXME: Map err to a valid reason */
1922 rej.reason = cpu_to_le16(0);
1923 l2cap_send_cmd(conn, cmd.ident, L2CAP_COMMAND_REJ, sizeof(rej), &rej);
1924 }
1925
1926 data += cmd_len;
1927 len -= cmd_len;
1928 }
1929
1930 kfree_skb(skb);
1931 }
1932
1933 static inline int l2cap_data_channel(struct l2cap_conn *conn, u16 cid, struct sk_buff *skb)
1934 {
1935 struct sock *sk;
1936
1937 sk = l2cap_get_chan_by_scid(&conn->chan_list, cid);
1938 if (!sk) {
1939 BT_DBG("unknown cid 0x%4.4x", cid);
1940 goto drop;
1941 }
1942
1943 BT_DBG("sk %p, len %d", sk, skb->len);
1944
1945 if (sk->sk_state != BT_CONNECTED)
1946 goto drop;
1947
1948 if (l2cap_pi(sk)->imtu < skb->len)
1949 goto drop;
1950
1951 /* If socket recv buffers overflows we drop data here
1952 * which is *bad* because L2CAP has to be reliable.
1953 * But we don't have any other choice. L2CAP doesn't
1954 * provide flow control mechanism. */
1955
1956 if (!sock_queue_rcv_skb(sk, skb))
1957 goto done;
1958
1959 drop:
1960 kfree_skb(skb);
1961
1962 done:
1963 if (sk)
1964 bh_unlock_sock(sk);
1965
1966 return 0;
1967 }
1968
1969 static inline int l2cap_conless_channel(struct l2cap_conn *conn, __le16 psm, struct sk_buff *skb)
1970 {
1971 struct sock *sk;
1972
1973 sk = l2cap_get_sock_by_psm(0, psm, conn->src);
1974 if (!sk)
1975 goto drop;
1976
1977 BT_DBG("sk %p, len %d", sk, skb->len);
1978
1979 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_CONNECTED)
1980 goto drop;
1981
1982 if (l2cap_pi(sk)->imtu < skb->len)
1983 goto drop;
1984
1985 if (!sock_queue_rcv_skb(sk, skb))
1986 goto done;
1987
1988 drop:
1989 kfree_skb(skb);
1990
1991 done:
1992 if (sk) bh_unlock_sock(sk);
1993 return 0;
1994 }
1995
1996 static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb)
1997 {
1998 struct l2cap_hdr *lh = (void *) skb->data;
1999 u16 cid, len;
2000 __le16 psm;
2001
2002 skb_pull(skb, L2CAP_HDR_SIZE);
2003 cid = __le16_to_cpu(lh->cid);
2004 len = __le16_to_cpu(lh->len);
2005
2006 BT_DBG("len %d, cid 0x%4.4x", len, cid);
2007
2008 switch (cid) {
2009 case 0x0001:
2010 l2cap_sig_channel(conn, skb);
2011 break;
2012
2013 case 0x0002:
2014 psm = get_unaligned((__le16 *) skb->data);
2015 skb_pull(skb, 2);
2016 l2cap_conless_channel(conn, psm, skb);
2017 break;
2018
2019 default:
2020 l2cap_data_channel(conn, cid, skb);
2021 break;
2022 }
2023 }
2024
2025 /* ---- L2CAP interface with lower layer (HCI) ---- */
2026
2027 static int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type)
2028 {
2029 int exact = 0, lm1 = 0, lm2 = 0;
2030 register struct sock *sk;
2031 struct hlist_node *node;
2032
2033 if (type != ACL_LINK)
2034 return 0;
2035
2036 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
2037
2038 /* Find listening sockets and check their link_mode */
2039 read_lock(&l2cap_sk_list.lock);
2040 sk_for_each(sk, node, &l2cap_sk_list.head) {
2041 if (sk->sk_state != BT_LISTEN)
2042 continue;
2043
2044 if (!bacmp(&bt_sk(sk)->src, &hdev->bdaddr)) {
2045 lm1 |= (HCI_LM_ACCEPT | l2cap_pi(sk)->link_mode);
2046 exact++;
2047 } else if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
2048 lm2 |= (HCI_LM_ACCEPT | l2cap_pi(sk)->link_mode);
2049 }
2050 read_unlock(&l2cap_sk_list.lock);
2051
2052 return exact ? lm1 : lm2;
2053 }
2054
2055 static int l2cap_connect_cfm(struct hci_conn *hcon, u8 status)
2056 {
2057 struct l2cap_conn *conn;
2058
2059 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
2060
2061 if (hcon->type != ACL_LINK)
2062 return 0;
2063
2064 if (!status) {
2065 conn = l2cap_conn_add(hcon, status);
2066 if (conn)
2067 l2cap_conn_ready(conn);
2068 } else
2069 l2cap_conn_del(hcon, bt_err(status));
2070
2071 return 0;
2072 }
2073
2074 static int l2cap_disconn_ind(struct hci_conn *hcon, u8 reason)
2075 {
2076 BT_DBG("hcon %p reason %d", hcon, reason);
2077
2078 if (hcon->type != ACL_LINK)
2079 return 0;
2080
2081 l2cap_conn_del(hcon, bt_err(reason));
2082
2083 return 0;
2084 }
2085
2086 static int l2cap_auth_cfm(struct hci_conn *hcon, u8 status)
2087 {
2088 struct l2cap_chan_list *l;
2089 struct l2cap_conn *conn = conn = hcon->l2cap_data;
2090 struct l2cap_conn_rsp rsp;
2091 struct sock *sk;
2092 int result;
2093
2094 if (!conn)
2095 return 0;
2096
2097 l = &conn->chan_list;
2098
2099 BT_DBG("conn %p", conn);
2100
2101 read_lock(&l->lock);
2102
2103 for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
2104 bh_lock_sock(sk);
2105
2106 if (sk->sk_state != BT_CONNECT2 ||
2107 (l2cap_pi(sk)->link_mode & L2CAP_LM_ENCRYPT) ||
2108 (l2cap_pi(sk)->link_mode & L2CAP_LM_SECURE)) {
2109 bh_unlock_sock(sk);
2110 continue;
2111 }
2112
2113 if (!status) {
2114 sk->sk_state = BT_CONFIG;
2115 result = 0;
2116 } else {
2117 sk->sk_state = BT_DISCONN;
2118 l2cap_sock_set_timer(sk, HZ/10);
2119 result = L2CAP_CR_SEC_BLOCK;
2120 }
2121
2122 rsp.scid = cpu_to_le16(l2cap_pi(sk)->dcid);
2123 rsp.dcid = cpu_to_le16(l2cap_pi(sk)->scid);
2124 rsp.result = cpu_to_le16(result);
2125 rsp.status = cpu_to_le16(0);
2126 l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
2127 L2CAP_CONN_RSP, sizeof(rsp), &rsp);
2128
2129 bh_unlock_sock(sk);
2130 }
2131
2132 read_unlock(&l->lock);
2133 return 0;
2134 }
2135
2136 static int l2cap_encrypt_cfm(struct hci_conn *hcon, u8 status)
2137 {
2138 struct l2cap_chan_list *l;
2139 struct l2cap_conn *conn = hcon->l2cap_data;
2140 struct l2cap_conn_rsp rsp;
2141 struct sock *sk;
2142 int result;
2143
2144 if (!conn)
2145 return 0;
2146
2147 l = &conn->chan_list;
2148
2149 BT_DBG("conn %p", conn);
2150
2151 read_lock(&l->lock);
2152
2153 for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
2154 bh_lock_sock(sk);
2155
2156 if (sk->sk_state != BT_CONNECT2) {
2157 bh_unlock_sock(sk);
2158 continue;
2159 }
2160
2161 if (!status) {
2162 sk->sk_state = BT_CONFIG;
2163 result = 0;
2164 } else {
2165 sk->sk_state = BT_DISCONN;
2166 l2cap_sock_set_timer(sk, HZ/10);
2167 result = L2CAP_CR_SEC_BLOCK;
2168 }
2169
2170 rsp.scid = cpu_to_le16(l2cap_pi(sk)->dcid);
2171 rsp.dcid = cpu_to_le16(l2cap_pi(sk)->scid);
2172 rsp.result = cpu_to_le16(result);
2173 rsp.status = cpu_to_le16(0);
2174 l2cap_send_cmd(conn, l2cap_pi(sk)->ident,
2175 L2CAP_CONN_RSP, sizeof(rsp), &rsp);
2176
2177 if (l2cap_pi(sk)->link_mode & L2CAP_LM_SECURE)
2178 hci_conn_change_link_key(hcon);
2179
2180 bh_unlock_sock(sk);
2181 }
2182
2183 read_unlock(&l->lock);
2184 return 0;
2185 }
2186
2187 static int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, u16 flags)
2188 {
2189 struct l2cap_conn *conn = hcon->l2cap_data;
2190
2191 if (!conn && !(conn = l2cap_conn_add(hcon, 0)))
2192 goto drop;
2193
2194 BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags);
2195
2196 if (flags & ACL_START) {
2197 struct l2cap_hdr *hdr;
2198 int len;
2199
2200 if (conn->rx_len) {
2201 BT_ERR("Unexpected start frame (len %d)", skb->len);
2202 kfree_skb(conn->rx_skb);
2203 conn->rx_skb = NULL;
2204 conn->rx_len = 0;
2205 l2cap_conn_unreliable(conn, ECOMM);
2206 }
2207
2208 if (skb->len < 2) {
2209 BT_ERR("Frame is too short (len %d)", skb->len);
2210 l2cap_conn_unreliable(conn, ECOMM);
2211 goto drop;
2212 }
2213
2214 hdr = (struct l2cap_hdr *) skb->data;
2215 len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE;
2216
2217 if (len == skb->len) {
2218 /* Complete frame received */
2219 l2cap_recv_frame(conn, skb);
2220 return 0;
2221 }
2222
2223 BT_DBG("Start: total len %d, frag len %d", len, skb->len);
2224
2225 if (skb->len > len) {
2226 BT_ERR("Frame is too long (len %d, expected len %d)",
2227 skb->len, len);
2228 l2cap_conn_unreliable(conn, ECOMM);
2229 goto drop;
2230 }
2231
2232 /* Allocate skb for the complete frame (with header) */
2233 if (!(conn->rx_skb = bt_skb_alloc(len, GFP_ATOMIC)))
2234 goto drop;
2235
2236 skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
2237 skb->len);
2238 conn->rx_len = len - skb->len;
2239 } else {
2240 BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len);
2241
2242 if (!conn->rx_len) {
2243 BT_ERR("Unexpected continuation frame (len %d)", skb->len);
2244 l2cap_conn_unreliable(conn, ECOMM);
2245 goto drop;
2246 }
2247
2248 if (skb->len > conn->rx_len) {
2249 BT_ERR("Fragment is too long (len %d, expected %d)",
2250 skb->len, conn->rx_len);
2251 kfree_skb(conn->rx_skb);
2252 conn->rx_skb = NULL;
2253 conn->rx_len = 0;
2254 l2cap_conn_unreliable(conn, ECOMM);
2255 goto drop;
2256 }
2257
2258 skb_copy_from_linear_data(skb, skb_put(conn->rx_skb, skb->len),
2259 skb->len);
2260 conn->rx_len -= skb->len;
2261
2262 if (!conn->rx_len) {
2263 /* Complete frame received */
2264 l2cap_recv_frame(conn, conn->rx_skb);
2265 conn->rx_skb = NULL;
2266 }
2267 }
2268
2269 drop:
2270 kfree_skb(skb);
2271 return 0;
2272 }
2273
2274 static ssize_t l2cap_sysfs_show(struct class *dev, char *buf)
2275 {
2276 struct sock *sk;
2277 struct hlist_node *node;
2278 char *str = buf;
2279
2280 read_lock_bh(&l2cap_sk_list.lock);
2281
2282 sk_for_each(sk, node, &l2cap_sk_list.head) {
2283 struct l2cap_pinfo *pi = l2cap_pi(sk);
2284
2285 str += sprintf(str, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d 0x%x\n",
2286 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst),
2287 sk->sk_state, btohs(pi->psm), pi->scid, pi->dcid,
2288 pi->imtu, pi->omtu, pi->link_mode);
2289 }
2290
2291 read_unlock_bh(&l2cap_sk_list.lock);
2292
2293 return (str - buf);
2294 }
2295
2296 static CLASS_ATTR(l2cap, S_IRUGO, l2cap_sysfs_show, NULL);
2297
2298 static const struct proto_ops l2cap_sock_ops = {
2299 .family = PF_BLUETOOTH,
2300 .owner = THIS_MODULE,
2301 .release = l2cap_sock_release,
2302 .bind = l2cap_sock_bind,
2303 .connect = l2cap_sock_connect,
2304 .listen = l2cap_sock_listen,
2305 .accept = l2cap_sock_accept,
2306 .getname = l2cap_sock_getname,
2307 .sendmsg = l2cap_sock_sendmsg,
2308 .recvmsg = bt_sock_recvmsg,
2309 .poll = bt_sock_poll,
2310 .mmap = sock_no_mmap,
2311 .socketpair = sock_no_socketpair,
2312 .ioctl = sock_no_ioctl,
2313 .shutdown = l2cap_sock_shutdown,
2314 .setsockopt = l2cap_sock_setsockopt,
2315 .getsockopt = l2cap_sock_getsockopt
2316 };
2317
2318 static struct net_proto_family l2cap_sock_family_ops = {
2319 .family = PF_BLUETOOTH,
2320 .owner = THIS_MODULE,
2321 .create = l2cap_sock_create,
2322 };
2323
2324 static struct hci_proto l2cap_hci_proto = {
2325 .name = "L2CAP",
2326 .id = HCI_PROTO_L2CAP,
2327 .connect_ind = l2cap_connect_ind,
2328 .connect_cfm = l2cap_connect_cfm,
2329 .disconn_ind = l2cap_disconn_ind,
2330 .auth_cfm = l2cap_auth_cfm,
2331 .encrypt_cfm = l2cap_encrypt_cfm,
2332 .recv_acldata = l2cap_recv_acldata
2333 };
2334
2335 static int __init l2cap_init(void)
2336 {
2337 int err;
2338
2339 err = proto_register(&l2cap_proto, 0);
2340 if (err < 0)
2341 return err;
2342
2343 err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
2344 if (err < 0) {
2345 BT_ERR("L2CAP socket registration failed");
2346 goto error;
2347 }
2348
2349 err = hci_register_proto(&l2cap_hci_proto);
2350 if (err < 0) {
2351 BT_ERR("L2CAP protocol registration failed");
2352 bt_sock_unregister(BTPROTO_L2CAP);
2353 goto error;
2354 }
2355
2356 if (class_create_file(bt_class, &class_attr_l2cap) < 0)
2357 BT_ERR("Failed to create L2CAP info file");
2358
2359 BT_INFO("L2CAP ver %s", VERSION);
2360 BT_INFO("L2CAP socket layer initialized");
2361
2362 return 0;
2363
2364 error:
2365 proto_unregister(&l2cap_proto);
2366 return err;
2367 }
2368
2369 static void __exit l2cap_exit(void)
2370 {
2371 class_remove_file(bt_class, &class_attr_l2cap);
2372
2373 if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
2374 BT_ERR("L2CAP socket unregistration failed");
2375
2376 if (hci_unregister_proto(&l2cap_hci_proto) < 0)
2377 BT_ERR("L2CAP protocol unregistration failed");
2378
2379 proto_unregister(&l2cap_proto);
2380 }
2381
2382 void l2cap_load(void)
2383 {
2384 /* Dummy function to trigger automatic L2CAP module loading by
2385 * other modules that use L2CAP sockets but don't use any other
2386 * symbols from it. */
2387 return;
2388 }
2389 EXPORT_SYMBOL(l2cap_load);
2390
2391 module_init(l2cap_init);
2392 module_exit(l2cap_exit);
2393
2394 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
2395 MODULE_DESCRIPTION("Bluetooth L2CAP ver " VERSION);
2396 MODULE_VERSION(VERSION);
2397 MODULE_LICENSE("GPL");
2398 MODULE_ALIAS("bt-proto-0");
linux 2.6.24.3 for JZ soc