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