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 SCO sockets. */
26
27 #include <linux/config.h>
28 #include <linux/module.h>
29
30 #include <linux/types.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/major.h>
34 #include <linux/sched.h>
35 #include <linux/slab.h>
36 #include <linux/poll.h>
37 #include <linux/fcntl.h>
38 #include <linux/init.h>
39 #include <linux/interrupt.h>
40 #include <linux/socket.h>
41 #include <linux/skbuff.h>
42 #include <linux/proc_fs.h>
43 #include <linux/seq_file.h>
44 #include <linux/list.h>
45 #include <net/sock.h>
46
47 #include <asm/system.h>
48 #include <asm/uaccess.h>
49
50 #include <net/bluetooth/bluetooth.h>
51 #include <net/bluetooth/hci_core.h>
52 #include <net/bluetooth/sco.h>
53
54 #ifndef CONFIG_BT_SCO_DEBUG
55 #undef BT_DBG
56 #define BT_DBG(D...)
57 #endif
58
59 #define VERSION "0.4"
60
61 static struct proto_ops sco_sock_ops;
62
63 static struct bt_sock_list sco_sk_list = {
64 .lock = RW_LOCK_UNLOCKED
65 };
66
67 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent);
68 static void sco_chan_del(struct sock *sk, int err);
69
70 static int sco_conn_del(struct hci_conn *conn, int err);
71
72 static void sco_sock_close(struct sock *sk);
73 static void sco_sock_kill(struct sock *sk);
74
75 /* ---- SCO timers ---- */
76 static void sco_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 sk->sk_err = ETIMEDOUT;
84 sk->sk_state_change(sk);
85 bh_unlock_sock(sk);
86
87 sco_sock_kill(sk);
88 sock_put(sk);
89 }
90
91 static void sco_sock_set_timer(struct sock *sk, long timeout)
92 {
93 BT_DBG("sock %p state %d timeout %ld", sk, sk->sk_state, timeout);
94 sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
95 }
96
97 static void sco_sock_clear_timer(struct sock *sk)
98 {
99 BT_DBG("sock %p state %d", sk, sk->sk_state);
100 sk_stop_timer(sk, &sk->sk_timer);
101 }
102
103 static void sco_sock_init_timer(struct sock *sk)
104 {
105 init_timer(&sk->sk_timer);
106 sk->sk_timer.function = sco_sock_timeout;
107 sk->sk_timer.data = (unsigned long)sk;
108 }
109
110 /* ---- SCO connections ---- */
111 static struct sco_conn *sco_conn_add(struct hci_conn *hcon, __u8 status)
112 {
113 struct hci_dev *hdev = hcon->hdev;
114 struct sco_conn *conn;
115
116 if ((conn = hcon->sco_data))
117 return conn;
118
119 if (status)
120 return conn;
121
122 if (!(conn = kmalloc(sizeof(struct sco_conn), GFP_ATOMIC)))
123 return NULL;
124 memset(conn, 0, sizeof(struct sco_conn));
125
126 spin_lock_init(&conn->lock);
127
128 hcon->sco_data = conn;
129 conn->hcon = hcon;
130
131 conn->src = &hdev->bdaddr;
132 conn->dst = &hcon->dst;
133
134 if (hdev->sco_mtu > 0)
135 conn->mtu = hdev->sco_mtu;
136 else
137 conn->mtu = 60;
138
139 BT_DBG("hcon %p conn %p", hcon, conn);
140 return conn;
141 }
142
143 static inline struct sock *sco_chan_get(struct sco_conn *conn)
144 {
145 struct sock *sk = NULL;
146 sco_conn_lock(conn);
147 sk = conn->sk;
148 sco_conn_unlock(conn);
149 return sk;
150 }
151
152 static int sco_conn_del(struct hci_conn *hcon, int err)
153 {
154 struct sco_conn *conn;
155 struct sock *sk;
156
157 if (!(conn = hcon->sco_data))
158 return 0;
159
160 BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
161
162 /* Kill socket */
163 if ((sk = sco_chan_get(conn))) {
164 bh_lock_sock(sk);
165 sco_sock_clear_timer(sk);
166 sco_chan_del(sk, err);
167 bh_unlock_sock(sk);
168 sco_sock_kill(sk);
169 }
170
171 hcon->sco_data = NULL;
172 kfree(conn);
173 return 0;
174 }
175
176 static inline int sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
177 {
178 int err = 0;
179
180 sco_conn_lock(conn);
181 if (conn->sk) {
182 err = -EBUSY;
183 } else {
184 __sco_chan_add(conn, sk, parent);
185 }
186 sco_conn_unlock(conn);
187 return err;
188 }
189
190 static int sco_connect(struct sock *sk)
191 {
192 bdaddr_t *src = &bt_sk(sk)->src;
193 bdaddr_t *dst = &bt_sk(sk)->dst;
194 struct sco_conn *conn;
195 struct hci_conn *hcon;
196 struct hci_dev *hdev;
197 int err = 0;
198
199 BT_DBG("%s -> %s", batostr(src), batostr(dst));
200
201 if (!(hdev = hci_get_route(dst, src)))
202 return -EHOSTUNREACH;
203
204 hci_dev_lock_bh(hdev);
205
206 err = -ENOMEM;
207
208 hcon = hci_connect(hdev, SCO_LINK, dst);
209 if (!hcon)
210 goto done;
211
212 conn = sco_conn_add(hcon, 0);
213 if (!conn) {
214 hci_conn_put(hcon);
215 goto done;
216 }
217
218 /* Update source addr of the socket */
219 bacpy(src, conn->src);
220
221 err = sco_chan_add(conn, sk, NULL);
222 if (err)
223 goto done;
224
225 if (hcon->state == BT_CONNECTED) {
226 sco_sock_clear_timer(sk);
227 sk->sk_state = BT_CONNECTED;
228 } else {
229 sk->sk_state = BT_CONNECT;
230 sco_sock_set_timer(sk, sk->sk_sndtimeo);
231 }
232 done:
233 hci_dev_unlock_bh(hdev);
234 hci_dev_put(hdev);
235 return err;
236 }
237
238 static inline int sco_send_frame(struct sock *sk, struct msghdr *msg, int len)
239 {
240 struct sco_conn *conn = sco_pi(sk)->conn;
241 struct sk_buff *skb;
242 int err, count;
243
244 /* Check outgoing MTU */
245 if (len > conn->mtu)
246 return -EINVAL;
247
248 BT_DBG("sk %p len %d", sk, len);
249
250 count = min_t(unsigned int, conn->mtu, len);
251 if (!(skb = bt_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err)))
252 return err;
253
254 if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
255 err = -EFAULT;
256 goto fail;
257 }
258
259 if ((err = hci_send_sco(conn->hcon, skb)) < 0)
260 goto fail;
261
262 return count;
263
264 fail:
265 kfree_skb(skb);
266 return err;
267 }
268
269 static inline void sco_recv_frame(struct sco_conn *conn, struct sk_buff *skb)
270 {
271 struct sock *sk = sco_chan_get(conn);
272
273 if (!sk)
274 goto drop;
275
276 BT_DBG("sk %p len %d", sk, skb->len);
277
278 if (sk->sk_state != BT_CONNECTED)
279 goto drop;
280
281 if (!sock_queue_rcv_skb(sk, skb))
282 return;
283
284 drop:
285 kfree_skb(skb);
286 return;
287 }
288
289 /* -------- Socket interface ---------- */
290 static struct sock *__sco_get_sock_by_addr(bdaddr_t *ba)
291 {
292 struct sock *sk;
293 struct hlist_node *node;
294
295 sk_for_each(sk, node, &sco_sk_list.head)
296 if (!bacmp(&bt_sk(sk)->src, ba))
297 goto found;
298 sk = NULL;
299 found:
300 return sk;
301 }
302
303 /* Find socket listening on source bdaddr.
304 * Returns closest match.
305 */
306 static struct sock *sco_get_sock_listen(bdaddr_t *src)
307 {
308 struct sock *sk = NULL, *sk1 = NULL;
309 struct hlist_node *node;
310
311 read_lock(&sco_sk_list.lock);
312
313 sk_for_each(sk, node, &sco_sk_list.head) {
314 if (sk->sk_state != BT_LISTEN)
315 continue;
316
317 /* Exact match. */
318 if (!bacmp(&bt_sk(sk)->src, src))
319 break;
320
321 /* Closest match */
322 if (!bacmp(&bt_sk(sk)->src, BDADDR_ANY))
323 sk1 = sk;
324 }
325
326 read_unlock(&sco_sk_list.lock);
327
328 return node ? sk : sk1;
329 }
330
331 static void sco_sock_destruct(struct sock *sk)
332 {
333 BT_DBG("sk %p", sk);
334
335 skb_queue_purge(&sk->sk_receive_queue);
336 skb_queue_purge(&sk->sk_write_queue);
337
338 if (sk->sk_protinfo)
339 kfree(sk->sk_protinfo);
340 }
341
342 static void sco_sock_cleanup_listen(struct sock *parent)
343 {
344 struct sock *sk;
345
346 BT_DBG("parent %p", parent);
347
348 /* Close not yet accepted channels */
349 while ((sk = bt_accept_dequeue(parent, NULL))) {
350 sco_sock_close(sk);
351 sco_sock_kill(sk);
352 }
353
354 parent->sk_state = BT_CLOSED;
355 parent->sk_zapped = 1;
356 }
357
358 /* Kill socket (only if zapped and orphan)
359 * Must be called on unlocked socket.
360 */
361 static void sco_sock_kill(struct sock *sk)
362 {
363 if (!sk->sk_zapped || sk->sk_socket)
364 return;
365
366 BT_DBG("sk %p state %d", sk, sk->sk_state);
367
368 /* Kill poor orphan */
369 bt_sock_unlink(&sco_sk_list, sk);
370 sock_set_flag(sk, SOCK_DEAD);
371 sock_put(sk);
372 }
373
374 /* Close socket.
375 * Must be called on unlocked socket.
376 */
377 static void sco_sock_close(struct sock *sk)
378 {
379 struct sco_conn *conn;
380
381 sco_sock_clear_timer(sk);
382
383 lock_sock(sk);
384
385 conn = sco_pi(sk)->conn;
386
387 BT_DBG("sk %p state %d conn %p socket %p", sk, sk->sk_state, conn, sk->sk_socket);
388
389 switch (sk->sk_state) {
390 case BT_LISTEN:
391 sco_sock_cleanup_listen(sk);
392 break;
393
394 case BT_CONNECTED:
395 case BT_CONFIG:
396 case BT_CONNECT:
397 case BT_DISCONN:
398 sco_chan_del(sk, ECONNRESET);
399 break;
400
401 default:
402 sk->sk_zapped = 1;
403 break;
404 };
405
406 release_sock(sk);
407
408 sco_sock_kill(sk);
409 }
410
411 static void sco_sock_init(struct sock *sk, struct sock *parent)
412 {
413 BT_DBG("sk %p", sk);
414
415 if (parent)
416 sk->sk_type = parent->sk_type;
417 }
418
419 static struct sock *sco_sock_alloc(struct socket *sock, int proto, int prio)
420 {
421 struct sock *sk;
422
423 sk = bt_sock_alloc(sock, proto, sizeof(struct sco_pinfo), prio);
424 if (!sk)
425 return NULL;
426
427 sk_set_owner(sk, THIS_MODULE);
428
429 sk->sk_destruct = sco_sock_destruct;
430 sk->sk_sndtimeo = SCO_CONN_TIMEOUT;
431 sk->sk_state = BT_OPEN;
432
433 sco_sock_init_timer(sk);
434
435 bt_sock_link(&sco_sk_list, sk);
436 return sk;
437 }
438
439 static int sco_sock_create(struct socket *sock, int protocol)
440 {
441 struct sock *sk;
442
443 BT_DBG("sock %p", sock);
444
445 sock->state = SS_UNCONNECTED;
446
447 if (sock->type != SOCK_SEQPACKET)
448 return -ESOCKTNOSUPPORT;
449
450 sock->ops = &sco_sock_ops;
451
452 if (!(sk = sco_sock_alloc(sock, protocol, GFP_KERNEL)))
453 return -ENOMEM;
454
455 sco_sock_init(sk, NULL);
456 return 0;
457 }
458
459 static int sco_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
460 {
461 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
462 struct sock *sk = sock->sk;
463 bdaddr_t *src = &sa->sco_bdaddr;
464 int err = 0;
465
466 BT_DBG("sk %p %s", sk, batostr(&sa->sco_bdaddr));
467
468 if (!addr || addr->sa_family != AF_BLUETOOTH)
469 return -EINVAL;
470
471 lock_sock(sk);
472
473 if (sk->sk_state != BT_OPEN) {
474 err = -EBADFD;
475 goto done;
476 }
477
478 write_lock_bh(&sco_sk_list.lock);
479
480 if (bacmp(src, BDADDR_ANY) && __sco_get_sock_by_addr(src)) {
481 err = -EADDRINUSE;
482 } else {
483 /* Save source address */
484 bacpy(&bt_sk(sk)->src, &sa->sco_bdaddr);
485 sk->sk_state = BT_BOUND;
486 }
487
488 write_unlock_bh(&sco_sk_list.lock);
489
490 done:
491 release_sock(sk);
492 return err;
493 }
494
495 static int sco_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
496 {
497 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
498 struct sock *sk = sock->sk;
499 int err = 0;
500
501
502 BT_DBG("sk %p", sk);
503
504 if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_sco))
505 return -EINVAL;
506
507 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND)
508 return -EBADFD;
509
510 if (sk->sk_type != SOCK_SEQPACKET)
511 return -EINVAL;
512
513 lock_sock(sk);
514
515 /* Set destination address and psm */
516 bacpy(&bt_sk(sk)->dst, &sa->sco_bdaddr);
517
518 if ((err = sco_connect(sk)))
519 goto done;
520
521 err = bt_sock_wait_state(sk, BT_CONNECTED,
522 sock_sndtimeo(sk, flags & O_NONBLOCK));
523
524 done:
525 release_sock(sk);
526 return err;
527 }
528
529 static int sco_sock_listen(struct socket *sock, int backlog)
530 {
531 struct sock *sk = sock->sk;
532 int err = 0;
533
534 BT_DBG("sk %p backlog %d", sk, backlog);
535
536 lock_sock(sk);
537
538 if (sk->sk_state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
539 err = -EBADFD;
540 goto done;
541 }
542
543 sk->sk_max_ack_backlog = backlog;
544 sk->sk_ack_backlog = 0;
545 sk->sk_state = BT_LISTEN;
546
547 done:
548 release_sock(sk);
549 return err;
550 }
551
552 static int sco_sock_accept(struct socket *sock, struct socket *newsock, int flags)
553 {
554 DECLARE_WAITQUEUE(wait, current);
555 struct sock *sk = sock->sk, *ch;
556 long timeo;
557 int err = 0;
558
559 lock_sock(sk);
560
561 if (sk->sk_state != BT_LISTEN) {
562 err = -EBADFD;
563 goto done;
564 }
565
566 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
567
568 BT_DBG("sk %p timeo %ld", sk, timeo);
569
570 /* Wait for an incoming connection. (wake-one). */
571 add_wait_queue_exclusive(sk->sk_sleep, &wait);
572 while (!(ch = bt_accept_dequeue(sk, newsock))) {
573 set_current_state(TASK_INTERRUPTIBLE);
574 if (!timeo) {
575 err = -EAGAIN;
576 break;
577 }
578
579 release_sock(sk);
580 timeo = schedule_timeout(timeo);
581 lock_sock(sk);
582
583 if (sk->sk_state != BT_LISTEN) {
584 err = -EBADFD;
585 break;
586 }
587
588 if (signal_pending(current)) {
589 err = sock_intr_errno(timeo);
590 break;
591 }
592 }
593 set_current_state(TASK_RUNNING);
594 remove_wait_queue(sk->sk_sleep, &wait);
595
596 if (err)
597 goto done;
598
599 newsock->state = SS_CONNECTED;
600
601 BT_DBG("new socket %p", ch);
602
603 done:
604 release_sock(sk);
605 return err;
606 }
607
608 static int sco_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
609 {
610 struct sockaddr_sco *sa = (struct sockaddr_sco *) addr;
611 struct sock *sk = sock->sk;
612
613 BT_DBG("sock %p, sk %p", sock, sk);
614
615 addr->sa_family = AF_BLUETOOTH;
616 *len = sizeof(struct sockaddr_sco);
617
618 if (peer)
619 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->dst);
620 else
621 bacpy(&sa->sco_bdaddr, &bt_sk(sk)->src);
622
623 return 0;
624 }
625
626 static int sco_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
627 struct msghdr *msg, size_t len)
628 {
629 struct sock *sk = sock->sk;
630 int err = 0;
631
632 BT_DBG("sock %p, sk %p", sock, sk);
633
634 if (sk->sk_err)
635 return sock_error(sk);
636
637 if (msg->msg_flags & MSG_OOB)
638 return -EOPNOTSUPP;
639
640 lock_sock(sk);
641
642 if (sk->sk_state == BT_CONNECTED)
643 err = sco_send_frame(sk, msg, len);
644 else
645 err = -ENOTCONN;
646
647 release_sock(sk);
648 return err;
649 }
650
651 static int sco_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
652 {
653 struct sock *sk = sock->sk;
654 int err = 0;
655
656 BT_DBG("sk %p", sk);
657
658 lock_sock(sk);
659
660 switch (optname) {
661 default:
662 err = -ENOPROTOOPT;
663 break;
664 }
665
666 release_sock(sk);
667 return err;
668 }
669
670 static int sco_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
671 {
672 struct sock *sk = sock->sk;
673 struct sco_options opts;
674 struct sco_conninfo cinfo;
675 int len, err = 0;
676
677 BT_DBG("sk %p", sk);
678
679 if (get_user(len, optlen))
680 return -EFAULT;
681
682 lock_sock(sk);
683
684 switch (optname) {
685 case SCO_OPTIONS:
686 if (sk->sk_state != BT_CONNECTED) {
687 err = -ENOTCONN;
688 break;
689 }
690
691 opts.mtu = sco_pi(sk)->conn->mtu;
692
693 BT_DBG("mtu %d", opts.mtu);
694
695 len = min_t(unsigned int, len, sizeof(opts));
696 if (copy_to_user(optval, (char *)&opts, len))
697 err = -EFAULT;
698
699 break;
700
701 case SCO_CONNINFO:
702 if (sk->sk_state != BT_CONNECTED) {
703 err = -ENOTCONN;
704 break;
705 }
706
707 cinfo.hci_handle = sco_pi(sk)->conn->hcon->handle;
708 memcpy(cinfo.dev_class, sco_pi(sk)->conn->hcon->dev_class, 3);
709
710 len = min_t(unsigned int, len, sizeof(cinfo));
711 if (copy_to_user(optval, (char *)&cinfo, len))
712 err = -EFAULT;
713
714 break;
715
716 default:
717 err = -ENOPROTOOPT;
718 break;
719 }
720
721 release_sock(sk);
722 return err;
723 }
724
725 static int sco_sock_release(struct socket *sock)
726 {
727 struct sock *sk = sock->sk;
728 int err = 0;
729
730 BT_DBG("sock %p, sk %p", sock, sk);
731
732 if (!sk)
733 return 0;
734
735 sco_sock_close(sk);
736
737 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime) {
738 lock_sock(sk);
739 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
740 release_sock(sk);
741 }
742
743 sock_orphan(sk);
744 sco_sock_kill(sk);
745 return err;
746 }
747
748 static void __sco_chan_add(struct sco_conn *conn, struct sock *sk, struct sock *parent)
749 {
750 BT_DBG("conn %p", conn);
751
752 sco_pi(sk)->conn = conn;
753 conn->sk = sk;
754
755 if (parent)
756 bt_accept_enqueue(parent, sk);
757 }
758
759 /* Delete channel.
760 * Must be called on the locked socket. */
761 static void sco_chan_del(struct sock *sk, int err)
762 {
763 struct sco_conn *conn;
764
765 conn = sco_pi(sk)->conn;
766
767 BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
768
769 if (conn) {
770 sco_conn_lock(conn);
771 conn->sk = NULL;
772 sco_pi(sk)->conn = NULL;
773 sco_conn_unlock(conn);
774 hci_conn_put(conn->hcon);
775 }
776
777 sk->sk_state = BT_CLOSED;
778 sk->sk_err = err;
779 sk->sk_state_change(sk);
780
781 sk->sk_zapped = 1;
782 }
783
784 static void sco_conn_ready(struct sco_conn *conn)
785 {
786 struct sock *parent, *sk;
787
788 BT_DBG("conn %p", conn);
789
790 sco_conn_lock(conn);
791
792 if ((sk = conn->sk)) {
793 sco_sock_clear_timer(sk);
794 bh_lock_sock(sk);
795 sk->sk_state = BT_CONNECTED;
796 sk->sk_state_change(sk);
797 bh_unlock_sock(sk);
798 } else {
799 parent = sco_get_sock_listen(conn->src);
800 if (!parent)
801 goto done;
802
803 bh_lock_sock(parent);
804
805 sk = sco_sock_alloc(NULL, BTPROTO_SCO, GFP_ATOMIC);
806 if (!sk) {
807 bh_unlock_sock(parent);
808 goto done;
809 }
810
811 sco_sock_init(sk, parent);
812
813 bacpy(&bt_sk(sk)->src, conn->src);
814 bacpy(&bt_sk(sk)->dst, conn->dst);
815
816 hci_conn_hold(conn->hcon);
817 __sco_chan_add(conn, sk, parent);
818
819 sk->sk_state = BT_CONNECTED;
820
821 /* Wake up parent */
822 parent->sk_data_ready(parent, 1);
823
824 bh_unlock_sock(parent);
825 }
826
827 done:
828 sco_conn_unlock(conn);
829 }
830
831 /* ----- SCO interface with lower layer (HCI) ----- */
832 static int sco_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
833 {
834 BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
835
836 /* Always accept connection */
837 return HCI_LM_ACCEPT;
838 }
839
840 static int sco_connect_cfm(struct hci_conn *hcon, __u8 status)
841 {
842 BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
843
844 if (hcon->type != SCO_LINK)
845 return 0;
846
847 if (!status) {
848 struct sco_conn *conn;
849
850 conn = sco_conn_add(hcon, status);
851 if (conn)
852 sco_conn_ready(conn);
853 } else
854 sco_conn_del(hcon, bt_err(status));
855
856 return 0;
857 }
858
859 static int sco_disconn_ind(struct hci_conn *hcon, __u8 reason)
860 {
861 BT_DBG("hcon %p reason %d", hcon, reason);
862
863 if (hcon->type != SCO_LINK)
864 return 0;
865
866 sco_conn_del(hcon, bt_err(reason));
867 return 0;
868 }
869
870 static int sco_recv_scodata(struct hci_conn *hcon, struct sk_buff *skb)
871 {
872 struct sco_conn *conn = hcon->sco_data;
873
874 if (!conn)
875 goto drop;
876
877 BT_DBG("conn %p len %d", conn, skb->len);
878
879 if (skb->len) {
880 sco_recv_frame(conn, skb);
881 return 0;
882 }
883
884 drop:
885 kfree_skb(skb);
886 return 0;
887 }
888
889 /* ---- Proc fs support ---- */
890 #ifdef CONFIG_PROC_FS
891 static void *sco_seq_start(struct seq_file *seq, loff_t *pos)
892 {
893 struct sock *sk;
894 struct hlist_node *node;
895 loff_t l = *pos;
896
897 read_lock_bh(&sco_sk_list.lock);
898
899 sk_for_each(sk, node, &sco_sk_list.head)
900 if (!l--)
901 goto found;
902 sk = NULL;
903 found:
904 return sk;
905 }
906
907 static void *sco_seq_next(struct seq_file *seq, void *e, loff_t *pos)
908 {
909 struct sock *sk = e;
910 (*pos)++;
911 return sk_next(sk);
912 }
913
914 static void sco_seq_stop(struct seq_file *seq, void *e)
915 {
916 read_unlock_bh(&sco_sk_list.lock);
917 }
918
919 static int sco_seq_show(struct seq_file *seq, void *e)
920 {
921 struct sock *sk = e;
922 seq_printf(seq, "%s %s %d\n",
923 batostr(&bt_sk(sk)->src), batostr(&bt_sk(sk)->dst), sk->sk_state);
924 return 0;
925 }
926
927 static struct seq_operations sco_seq_ops = {
928 .start = sco_seq_start,
929 .next = sco_seq_next,
930 .stop = sco_seq_stop,
931 .show = sco_seq_show
932 };
933
934 static int sco_seq_open(struct inode *inode, struct file *file)
935 {
936 return seq_open(file, &sco_seq_ops);
937 }
938
939 static struct file_operations sco_seq_fops = {
940 .owner = THIS_MODULE,
941 .open = sco_seq_open,
942 .read = seq_read,
943 .llseek = seq_lseek,
944 .release = seq_release,
945 };
946
947 static int __init sco_proc_init(void)
948 {
949 struct proc_dir_entry *p = create_proc_entry("sco", S_IRUGO, proc_bt);
950 if (!p)
951 return -ENOMEM;
952 p->owner = THIS_MODULE;
953 p->proc_fops = &sco_seq_fops;
954 return 0;
955 }
956
957 static void __exit sco_proc_cleanup(void)
958 {
959 remove_proc_entry("sco", proc_bt);
960 }
961
962 #else /* CONFIG_PROC_FS */
963
964 static int __init sco_proc_init(void)
965 {
966 return 0;
967 }
968
969 static void __exit sco_proc_cleanup(void)
970 {
971 return;
972 }
973 #endif /* CONFIG_PROC_FS */
974
975 static struct proto_ops sco_sock_ops = {
976 .family = PF_BLUETOOTH,
977 .owner = THIS_MODULE,
978 .release = sco_sock_release,
979 .bind = sco_sock_bind,
980 .connect = sco_sock_connect,
981 .listen = sco_sock_listen,
982 .accept = sco_sock_accept,
983 .getname = sco_sock_getname,
984 .sendmsg = sco_sock_sendmsg,
985 .recvmsg = bt_sock_recvmsg,
986 .poll = bt_sock_poll,
987 .ioctl = sock_no_ioctl,
988 .mmap = sock_no_mmap,
989 .socketpair = sock_no_socketpair,
990 .shutdown = sock_no_shutdown,
991 .setsockopt = sco_sock_setsockopt,
992 .getsockopt = sco_sock_getsockopt
993 };
994
995 static struct net_proto_family sco_sock_family_ops = {
996 .family = PF_BLUETOOTH,
997 .owner = THIS_MODULE,
998 .create = sco_sock_create,
999 };
1000
1001 static struct hci_proto sco_hci_proto = {
1002 .name = "SCO",
1003 .id = HCI_PROTO_SCO,
1004 .connect_ind = sco_connect_ind,
1005 .connect_cfm = sco_connect_cfm,
1006 .disconn_ind = sco_disconn_ind,
1007 .recv_scodata = sco_recv_scodata
1008 };
1009
1010 static int __init sco_init(void)
1011 {
1012 int err;
1013
1014 if ((err = bt_sock_register(BTPROTO_SCO, &sco_sock_family_ops))) {
1015 BT_ERR("SCO socket registration failed");
1016 return err;
1017 }
1018
1019 if ((err = hci_register_proto(&sco_hci_proto))) {
1020 BT_ERR("SCO protocol registration failed");
1021 return err;
1022 }
1023
1024 sco_proc_init();
1025
1026 BT_INFO("SCO (Voice Link) ver %s", VERSION);
1027 BT_INFO("SCO socket layer initialized");
1028
1029 return 0;
1030 }
1031
1032 static void __exit sco_exit(void)
1033 {
1034 int err;
1035
1036 sco_proc_cleanup();
1037
1038 /* Unregister socket, protocol and notifier */
1039 if ((err = bt_sock_unregister(BTPROTO_SCO)))
1040 BT_ERR("SCO socket unregistration failed. %d", err);
1041
1042 if ((err = hci_unregister_proto(&sco_hci_proto)))
1043 BT_ERR("SCO protocol unregistration failed. %d", err);
1044 }
1045
1046 module_init(sco_init);
1047 module_exit(sco_exit);
1048
1049 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
1050 MODULE_DESCRIPTION("Bluetooth SCO ver " VERSION);
1051 MODULE_VERSION(VERSION);
1052 MODULE_LICENSE("GPL");
1053 MODULE_ALIAS("bt-proto-2");
1054
|
This page was automatically generated by the
LXR engine.
|