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