blob: fb031fe9be9ed140bce6fdfe6092f3ab6df8ff87 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 address family and sockets. */
26
27#include <linux/config.h>
28#include <linux/module.h>
29
30#include <linux/types.h>
31#include <linux/list.h>
32#include <linux/errno.h>
33#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/sched.h>
35#include <linux/slab.h>
36#include <linux/skbuff.h>
37#include <linux/init.h>
38#include <linux/poll.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include <net/sock.h>
40
41#if defined(CONFIG_KMOD)
42#include <linux/kmod.h>
43#endif
44
45#include <net/bluetooth/bluetooth.h>
46
47#ifndef CONFIG_BT_SOCK_DEBUG
48#undef BT_DBG
49#define BT_DBG(D...)
50#endif
51
Marcel Holtmannbe9d1222005-11-08 09:57:38 -080052#define VERSION "2.8"
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
54/* Bluetooth sockets */
55#define BT_MAX_PROTO 8
56static struct net_proto_family *bt_proto[BT_MAX_PROTO];
57
58int bt_sock_register(int proto, struct net_proto_family *ops)
59{
60 if (proto < 0 || proto >= BT_MAX_PROTO)
61 return -EINVAL;
62
63 if (bt_proto[proto])
64 return -EEXIST;
65
66 bt_proto[proto] = ops;
67 return 0;
68}
69EXPORT_SYMBOL(bt_sock_register);
70
71int bt_sock_unregister(int proto)
72{
73 if (proto < 0 || proto >= BT_MAX_PROTO)
74 return -EINVAL;
75
76 if (!bt_proto[proto])
77 return -ENOENT;
78
79 bt_proto[proto] = NULL;
80 return 0;
81}
82EXPORT_SYMBOL(bt_sock_unregister);
83
84static int bt_sock_create(struct socket *sock, int proto)
85{
86 int err = 0;
87
88 if (proto < 0 || proto >= BT_MAX_PROTO)
89 return -EINVAL;
90
91#if defined(CONFIG_KMOD)
92 if (!bt_proto[proto]) {
93 request_module("bt-proto-%d", proto);
94 }
95#endif
96 err = -EPROTONOSUPPORT;
97 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
98 err = bt_proto[proto]->create(sock, proto);
99 module_put(bt_proto[proto]->owner);
100 }
101 return err;
102}
103
104void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
105{
106 write_lock_bh(&l->lock);
107 sk_add_node(sk, &l->head);
108 write_unlock_bh(&l->lock);
109}
110EXPORT_SYMBOL(bt_sock_link);
111
112void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
113{
114 write_lock_bh(&l->lock);
115 sk_del_node_init(sk);
116 write_unlock_bh(&l->lock);
117}
118EXPORT_SYMBOL(bt_sock_unlink);
119
120void bt_accept_enqueue(struct sock *parent, struct sock *sk)
121{
122 BT_DBG("parent %p, sk %p", parent, sk);
123
124 sock_hold(sk);
125 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
126 bt_sk(sk)->parent = parent;
127 parent->sk_ack_backlog++;
128}
129EXPORT_SYMBOL(bt_accept_enqueue);
130
131void bt_accept_unlink(struct sock *sk)
132{
133 BT_DBG("sk %p state %d", sk, sk->sk_state);
134
135 list_del_init(&bt_sk(sk)->accept_q);
136 bt_sk(sk)->parent->sk_ack_backlog--;
137 bt_sk(sk)->parent = NULL;
138 sock_put(sk);
139}
140EXPORT_SYMBOL(bt_accept_unlink);
141
142struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
143{
144 struct list_head *p, *n;
145 struct sock *sk;
146
147 BT_DBG("parent %p", parent);
148
149 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
150 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
151
152 lock_sock(sk);
153
154 /* FIXME: Is this check still needed */
155 if (sk->sk_state == BT_CLOSED) {
156 release_sock(sk);
157 bt_accept_unlink(sk);
158 continue;
159 }
160
161 if (sk->sk_state == BT_CONNECTED || !newsock) {
162 bt_accept_unlink(sk);
163 if (newsock)
164 sock_graft(sk, newsock);
165 release_sock(sk);
166 return sk;
167 }
168
169 release_sock(sk);
170 }
171 return NULL;
172}
173EXPORT_SYMBOL(bt_accept_dequeue);
174
175int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
176 struct msghdr *msg, size_t len, int flags)
177{
178 int noblock = flags & MSG_DONTWAIT;
179 struct sock *sk = sock->sk;
180 struct sk_buff *skb;
181 size_t copied;
182 int err;
183
184 BT_DBG("sock %p sk %p len %d", sock, sk, len);
185
186 if (flags & (MSG_OOB))
187 return -EOPNOTSUPP;
188
189 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
190 if (sk->sk_shutdown & RCV_SHUTDOWN)
191 return 0;
192 return err;
193 }
194
195 msg->msg_namelen = 0;
196
197 copied = skb->len;
198 if (len < copied) {
199 msg->msg_flags |= MSG_TRUNC;
200 copied = len;
201 }
202
203 skb->h.raw = skb->data;
204 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
205
206 skb_free_datagram(sk, skb);
207
208 return err ? : copied;
209}
210EXPORT_SYMBOL(bt_sock_recvmsg);
211
212static inline unsigned int bt_accept_poll(struct sock *parent)
213{
214 struct list_head *p, *n;
215 struct sock *sk;
216
217 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
218 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
219 if (sk->sk_state == BT_CONNECTED)
220 return POLLIN | POLLRDNORM;
221 }
222
223 return 0;
224}
225
226unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
227{
228 struct sock *sk = sock->sk;
229 unsigned int mask = 0;
230
231 BT_DBG("sock %p, sk %p", sock, sk);
232
233 poll_wait(file, sk->sk_sleep, wait);
234
235 if (sk->sk_state == BT_LISTEN)
236 return bt_accept_poll(sk);
237
238 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
239 mask |= POLLERR;
240
241 if (sk->sk_shutdown == SHUTDOWN_MASK)
242 mask |= POLLHUP;
243
244 if (!skb_queue_empty(&sk->sk_receive_queue) ||
245 (sk->sk_shutdown & RCV_SHUTDOWN))
246 mask |= POLLIN | POLLRDNORM;
247
248 if (sk->sk_state == BT_CLOSED)
249 mask |= POLLHUP;
250
251 if (sk->sk_state == BT_CONNECT ||
252 sk->sk_state == BT_CONNECT2 ||
253 sk->sk_state == BT_CONFIG)
254 return mask;
255
256 if (sock_writeable(sk))
257 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
258 else
259 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
260
261 return mask;
262}
263EXPORT_SYMBOL(bt_sock_poll);
264
265int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
266{
267 DECLARE_WAITQUEUE(wait, current);
268 int err = 0;
269
270 BT_DBG("sk %p", sk);
271
272 add_wait_queue(sk->sk_sleep, &wait);
273 while (sk->sk_state != state) {
274 set_current_state(TASK_INTERRUPTIBLE);
275
276 if (!timeo) {
277 err = -EAGAIN;
278 break;
279 }
280
281 if (signal_pending(current)) {
282 err = sock_intr_errno(timeo);
283 break;
284 }
285
286 release_sock(sk);
287 timeo = schedule_timeout(timeo);
288 lock_sock(sk);
289
Benjamin LaHaisec1cbe4b2005-12-13 23:22:19 -0800290 err = sock_error(sk);
291 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 }
294 set_current_state(TASK_RUNNING);
295 remove_wait_queue(sk->sk_sleep, &wait);
296 return err;
297}
298EXPORT_SYMBOL(bt_sock_wait_state);
299
300static struct net_proto_family bt_sock_family_ops = {
301 .owner = THIS_MODULE,
302 .family = PF_BLUETOOTH,
303 .create = bt_sock_create,
304};
305
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306static int __init bt_init(void)
307{
308 BT_INFO("Core ver %s", VERSION);
309
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 sock_register(&bt_sock_family_ops);
311
312 BT_INFO("HCI device and connection manager initialized");
313
314 bt_sysfs_init();
315
316 hci_sock_init();
317
318 return 0;
319}
320
321static void __exit bt_exit(void)
322{
323 hci_sock_cleanup();
324
325 bt_sysfs_cleanup();
326
327 sock_unregister(PF_BLUETOOTH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328}
329
330subsys_initcall(bt_init);
331module_exit(bt_exit);
332
333MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
334MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
335MODULE_VERSION(VERSION);
336MODULE_LICENSE("GPL");
337MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);