2 HIDP implementation for Linux Bluetooth stack (BlueZ).
3 Copyright (C) 2003-2004 Marcel Holtmann <marcel@holtmann.org>
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License version 2 as
7 published by the Free Software Foundation;
9 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
10 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
11 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
12 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
13 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
14 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
19 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
20 SOFTWARE IS DISCLAIMED.
23 #include <linux/module.h>
25 #include <linux/types.h>
26 #include <linux/capability.h>
27 #include <linux/errno.h>
28 #include <linux/kernel.h>
29 #include <linux/poll.h>
30 #include <linux/fcntl.h>
31 #include <linux/skbuff.h>
32 #include <linux/socket.h>
33 #include <linux/ioctl.h>
34 #include <linux/file.h>
35 #include <linux/init.h>
36 #include <linux/compat.h>
37 #include <linux/gfp.h>
42 static int hidp_sock_release(struct socket *sock)
44 struct sock *sk = sock->sk;
46 BT_DBG("sock %p sk %p", sock, sk);
57 static int hidp_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
59 void __user *argp = (void __user *) arg;
60 struct hidp_connadd_req ca;
61 struct hidp_conndel_req cd;
62 struct hidp_connlist_req cl;
63 struct hidp_conninfo ci;
68 BT_DBG("cmd %x arg %lx", cmd, arg);
72 if (!capable(CAP_NET_ADMIN))
75 if (copy_from_user(&ca, argp, sizeof(ca)))
78 csock = sockfd_lookup(ca.ctrl_sock, &err);
82 isock = sockfd_lookup(ca.intr_sock, &err);
87 ca.name[sizeof(ca.name)-1] = 0;
89 if (csock->sk->sk_state != BT_CONNECTED ||
90 isock->sk->sk_state != BT_CONNECTED) {
96 err = hidp_add_connection(&ca, csock, isock);
98 if (copy_to_user(argp, &ca, sizeof(ca)))
108 if (!capable(CAP_NET_ADMIN))
111 if (copy_from_user(&cd, argp, sizeof(cd)))
114 return hidp_del_connection(&cd);
116 case HIDPGETCONNLIST:
117 if (copy_from_user(&cl, argp, sizeof(cl)))
123 err = hidp_get_connlist(&cl);
124 if (!err && copy_to_user(argp, &cl, sizeof(cl)))
129 case HIDPGETCONNINFO:
130 if (copy_from_user(&ci, argp, sizeof(ci)))
133 err = hidp_get_conninfo(&ci);
134 if (!err && copy_to_user(argp, &ci, sizeof(ci)))
144 struct compat_hidp_connadd_req {
145 int ctrl_sock; /* Connected control socket */
146 int intr_sock; /* Connected interrupt socket */
149 compat_uptr_t rd_data;
160 static int hidp_sock_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
162 if (cmd == HIDPGETCONNLIST) {
163 struct hidp_connlist_req cl;
167 if (get_user(cl.cnum, (uint32_t __user *) arg) ||
168 get_user(uci, (u32 __user *) (arg + 4)))
171 cl.ci = compat_ptr(uci);
176 err = hidp_get_connlist(&cl);
178 if (!err && put_user(cl.cnum, (uint32_t __user *) arg))
182 } else if (cmd == HIDPCONNADD) {
183 struct compat_hidp_connadd_req ca;
184 struct hidp_connadd_req __user *uca;
186 uca = compat_alloc_user_space(sizeof(*uca));
188 if (copy_from_user(&ca, (void __user *) arg, sizeof(ca)))
191 if (put_user(ca.ctrl_sock, &uca->ctrl_sock) ||
192 put_user(ca.intr_sock, &uca->intr_sock) ||
193 put_user(ca.parser, &uca->parser) ||
194 put_user(ca.rd_size, &uca->rd_size) ||
195 put_user(compat_ptr(ca.rd_data), &uca->rd_data) ||
196 put_user(ca.country, &uca->country) ||
197 put_user(ca.subclass, &uca->subclass) ||
198 put_user(ca.vendor, &uca->vendor) ||
199 put_user(ca.product, &uca->product) ||
200 put_user(ca.version, &uca->version) ||
201 put_user(ca.flags, &uca->flags) ||
202 put_user(ca.idle_to, &uca->idle_to) ||
203 copy_to_user(&uca->name[0], &ca.name[0], 128))
206 arg = (unsigned long) uca;
208 /* Fall through. We don't actually write back any _changes_
209 to the structure anyway, so there's no need to copy back
210 into the original compat version */
213 return hidp_sock_ioctl(sock, cmd, arg);
217 static const struct proto_ops hidp_sock_ops = {
218 .family = PF_BLUETOOTH,
219 .owner = THIS_MODULE,
220 .release = hidp_sock_release,
221 .ioctl = hidp_sock_ioctl,
223 .compat_ioctl = hidp_sock_compat_ioctl,
225 .bind = sock_no_bind,
226 .getname = sock_no_getname,
227 .sendmsg = sock_no_sendmsg,
228 .recvmsg = sock_no_recvmsg,
229 .poll = sock_no_poll,
230 .listen = sock_no_listen,
231 .shutdown = sock_no_shutdown,
232 .setsockopt = sock_no_setsockopt,
233 .getsockopt = sock_no_getsockopt,
234 .connect = sock_no_connect,
235 .socketpair = sock_no_socketpair,
236 .accept = sock_no_accept,
240 static struct proto hidp_proto = {
242 .owner = THIS_MODULE,
243 .obj_size = sizeof(struct bt_sock)
246 static int hidp_sock_create(struct net *net, struct socket *sock, int protocol,
251 BT_DBG("sock %p", sock);
253 if (sock->type != SOCK_RAW)
254 return -ESOCKTNOSUPPORT;
256 sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hidp_proto);
260 sock_init_data(sock, sk);
262 sock->ops = &hidp_sock_ops;
264 sock->state = SS_UNCONNECTED;
266 sock_reset_flag(sk, SOCK_ZAPPED);
268 sk->sk_protocol = protocol;
269 sk->sk_state = BT_OPEN;
274 static const struct net_proto_family hidp_sock_family_ops = {
275 .family = PF_BLUETOOTH,
276 .owner = THIS_MODULE,
277 .create = hidp_sock_create
280 int __init hidp_init_sockets(void)
284 err = proto_register(&hidp_proto, 0);
288 err = bt_sock_register(BTPROTO_HIDP, &hidp_sock_family_ops);
295 BT_ERR("Can't register HIDP socket");
296 proto_unregister(&hidp_proto);
300 void __exit hidp_cleanup_sockets(void)
302 if (bt_sock_unregister(BTPROTO_HIDP) < 0)
303 BT_ERR("Can't unregister HIDP socket");
305 proto_unregister(&hidp_proto);