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